diff --git a/.cargo/config.toml b/.cargo/config.toml
index 8db58d238003c29df6dbc9fa733c6d5521340103..717c5e18c8d294bacf65207bc6b8ecb7dba1b152 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -19,8 +19,6 @@ rustflags = [
     "windows_slim_errors",        # This cfg will reduce the size of `windows::core::Error` from 16 bytes to 4 bytes
     "-C",
     "target-feature=+crt-static", # This fixes the linking issue when compiling livekit on Windows
-    "-C",
-    "link-arg=-fuse-ld=lld",
 ]
 
 [env]
diff --git a/.config/hakari.toml b/.config/hakari.toml
index 8ce0b77490482ab5ff2d781fb78fd86b56959a6a..e8f094e618b39138df95bbdb58e5800cd396fad5 100644
--- a/.config/hakari.toml
+++ b/.config/hakari.toml
@@ -41,5 +41,4 @@ workspace-members = [
     "slash_commands_example",
     "zed_snippets",
     "zed_test_extension",
-    "zed_toml",
 ]
diff --git a/.gitattributes b/.gitattributes
index 0dedc2d567dac982b217453c266a046b09ea4830..57afd4ea6942bd3985fb7395101800706d7b4ae6 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -2,4 +2,4 @@
 *.json linguist-language=JSON-with-Comments
 
 # Ensure the WSL script always has LF line endings, even on Windows
-crates/zed/resources/windows/zed-wsl text eol=lf
+crates/zed/resources/windows/zed.sh text eol=lf
diff --git a/.rules b/.rules
index da009f1877b4c6ef2f0613995391852d4bf1dc8a..2f2b9cd705d95775bedf092bc4e6254136da6117 100644
--- a/.rules
+++ b/.rules
@@ -12,6 +12,19 @@
   - Example: avoid `let _ = client.request(...).await?;` - use `client.request(...).await?;` instead
 * When implementing async operations that may fail, ensure errors propagate to the UI layer so users get meaningful feedback.
 * Never create files with `mod.rs` paths - prefer `src/some_module.rs` instead of `src/some_module/mod.rs`.
+* When creating new crates, prefer specifying the library root path in `Cargo.toml` using `[lib] path = "...rs"` instead of the default `lib.rs`, to maintain consistent and descriptive naming (e.g., `gpui.rs` or `main.rs`).
+* Avoid creative additions unless explicitly requested
+* Use full words for variable names (no abbreviations like "q" for "queue")
+* Use variable shadowing to scope clones in async contexts for clarity, minimizing the lifetime of borrowed references.
+  Example:
+  ```rust
+  executor.spawn({
+      let task_ran = task_ran.clone();
+      async move {
+          *task_ran.borrow_mut() = true;
+      }
+  });
+  ```
 
 # GPUI
 
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 407ba002c7bc5a75c922faa72f1f270c62e82410..1c0b1e363ed0f04ff33c070a4a84815cece78545 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -65,7 +65,7 @@ If you would like to add a new icon to the Zed icon theme, [open a Discussion](h
 
 ## Bird's-eye view of Zed
 
-We suggest you keep the [zed glossary](docs/src/development/GLOSSARY.md) at your side when starting out. It lists and explains some of the structures and terms you will see throughout the codebase.
+We suggest you keep the [zed glossary](docs/src/development/glossary.md) at your side when starting out. It lists and explains some of the structures and terms you will see throughout the codebase.
 
 Zed is made up of several smaller crates - let's go over those you're most likely to interact with:
 
diff --git a/Cargo.lock b/Cargo.lock
index 58d01da63372431e107ea9c0b17fde0700f9050f..3c25fc5b008332d3c63ceb52b36d7b4b44a132cb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -26,7 +26,7 @@ dependencies = [
  "portable-pty",
  "project",
  "prompt_store",
- "rand 0.8.5",
+ "rand 0.9.1",
  "serde",
  "serde_json",
  "settings",
@@ -79,7 +79,7 @@ dependencies = [
  "log",
  "pretty_assertions",
  "project",
- "rand 0.8.5",
+ "rand 0.9.1",
  "serde_json",
  "settings",
  "text",
@@ -172,7 +172,7 @@ dependencies = [
  "pretty_assertions",
  "project",
  "prompt_store",
- "rand 0.8.5",
+ "rand 0.9.1",
  "ref-cast",
  "rope",
  "schemars",
@@ -308,22 +308,18 @@ dependencies = [
  "libc",
  "log",
  "nix 0.29.0",
- "node_runtime",
- "paths",
  "project",
  "reqwest_client",
- "schemars",
- "semver",
  "serde",
  "serde_json",
  "settings",
  "smol",
+ "task",
  "tempfile",
  "thiserror 2.0.12",
  "ui",
  "util",
  "watch",
- "which 6.0.3",
  "workspace-hack",
 ]
 
@@ -408,7 +404,7 @@ dependencies = [
  "project",
  "prompt_store",
  "proto",
- "rand 0.8.5",
+ "rand 0.9.1",
  "release_channel",
  "rope",
  "rules_library",
@@ -486,6 +482,7 @@ dependencies = [
  "client",
  "cloud_llm_client",
  "component",
+ "feature_flags",
  "gpui",
  "language_model",
  "serde",
@@ -834,7 +831,7 @@ dependencies = [
  "project",
  "prompt_store",
  "proto",
- "rand 0.8.5",
+ "rand 0.9.1",
  "regex",
  "rpc",
  "serde",
@@ -933,7 +930,7 @@ dependencies = [
  "parking_lot",
  "pretty_assertions",
  "project",
- "rand 0.8.5",
+ "rand 0.9.1",
  "regex",
  "serde",
  "serde_json",
@@ -985,7 +982,7 @@ dependencies = [
  "pretty_assertions",
  "project",
  "prompt_store",
- "rand 0.8.5",
+ "rand 0.9.1",
  "regex",
  "reqwest_client",
  "rust-embed",
@@ -2291,7 +2288,7 @@ dependencies = [
 [[package]]
 name = "blade-graphics"
 version = "0.6.0"
-source = "git+https://github.com/kvark/blade?rev=e0ec4e720957edd51b945b64dd85605ea54bcfe5#e0ec4e720957edd51b945b64dd85605ea54bcfe5"
+source = "git+https://github.com/kvark/blade?rev=bfa594ea697d4b6326ea29f747525c85ecf933b9#bfa594ea697d4b6326ea29f747525c85ecf933b9"
 dependencies = [
  "ash",
  "ash-window",
@@ -2324,7 +2321,7 @@ dependencies = [
 [[package]]
 name = "blade-macros"
 version = "0.3.0"
-source = "git+https://github.com/kvark/blade?rev=e0ec4e720957edd51b945b64dd85605ea54bcfe5#e0ec4e720957edd51b945b64dd85605ea54bcfe5"
+source = "git+https://github.com/kvark/blade?rev=bfa594ea697d4b6326ea29f747525c85ecf933b9#bfa594ea697d4b6326ea29f747525c85ecf933b9"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2334,7 +2331,7 @@ dependencies = [
 [[package]]
 name = "blade-util"
 version = "0.2.0"
-source = "git+https://github.com/kvark/blade?rev=e0ec4e720957edd51b945b64dd85605ea54bcfe5#e0ec4e720957edd51b945b64dd85605ea54bcfe5"
+source = "git+https://github.com/kvark/blade?rev=bfa594ea697d4b6326ea29f747525c85ecf933b9#bfa594ea697d4b6326ea29f747525c85ecf933b9"
 dependencies = [
  "blade-graphics",
  "bytemuck",
@@ -2351,19 +2348,6 @@ dependencies = [
  "digest",
 ]
 
-[[package]]
-name = "blake3"
-version = "1.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3888aaa89e4b2a40fca9848e400f6a658a5a3978de7be858e209cafa8be9a4a0"
-dependencies = [
- "arrayref",
- "arrayvec",
- "cc",
- "cfg-if",
- "constant_time_eq 0.3.1",
-]
-
 [[package]]
 name = "block"
 version = "0.1.6"
@@ -2478,7 +2462,7 @@ dependencies = [
  "language",
  "log",
  "pretty_assertions",
- "rand 0.8.5",
+ "rand 0.9.1",
  "rope",
  "serde_json",
  "sum_tree",
@@ -2899,11 +2883,9 @@ dependencies = [
  "language",
  "log",
  "postage",
- "rand 0.8.5",
  "release_channel",
  "rpc",
  "settings",
- "sum_tree",
  "text",
  "time",
  "util",
@@ -3070,7 +3052,6 @@ dependencies = [
  "clock",
  "cloud_api_client",
  "cloud_llm_client",
- "cocoa 0.26.0",
  "collections",
  "credentials_provider",
  "derive_more",
@@ -3083,10 +3064,11 @@ dependencies = [
  "http_client_tls",
  "httparse",
  "log",
+ "objc2-foundation",
  "parking_lot",
  "paths",
  "postage",
- "rand 0.8.5",
+ "rand 0.9.1",
  "regex",
  "release_channel",
  "rpc",
@@ -3335,7 +3317,7 @@ dependencies = [
  "prometheus",
  "prompt_store",
  "prost 0.9.0",
- "rand 0.8.5",
+ "rand 0.9.1",
  "recent_projects",
  "release_channel",
  "remote",
@@ -3391,12 +3373,10 @@ dependencies = [
  "collections",
  "db",
  "editor",
- "emojis",
  "futures 0.3.31",
  "fuzzy",
  "gpui",
  "http_client",
- "language",
  "log",
  "menu",
  "notifications",
@@ -3404,7 +3384,6 @@ dependencies = [
  "pretty_assertions",
  "project",
  "release_channel",
- "rich_text",
  "rpc",
  "schemars",
  "serde",
@@ -3515,6 +3494,7 @@ name = "component"
 version = "0.1.0"
 dependencies = [
  "collections",
+ "documented",
  "gpui",
  "inventory",
  "parking_lot",
@@ -3577,12 +3557,6 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"
 
-[[package]]
-name = "constant_time_eq"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6"
-
 [[package]]
 name = "context_server"
 version = "0.1.0"
@@ -4697,7 +4671,7 @@ dependencies = [
  "markdown",
  "pretty_assertions",
  "project",
- "rand 0.8.5",
+ "rand 0.9.1",
  "serde",
  "serde_json",
  "settings",
@@ -5068,7 +5042,7 @@ dependencies = [
  "parking_lot",
  "pretty_assertions",
  "project",
- "rand 0.8.5",
+ "rand 0.9.1",
  "regex",
  "release_channel",
  "rpc",
@@ -5563,7 +5537,7 @@ dependencies = [
  "parking_lot",
  "paths",
  "project",
- "rand 0.8.5",
+ "rand 0.9.1",
  "release_channel",
  "remote",
  "reqwest_client",
@@ -6163,17 +6137,6 @@ dependencies = [
  "futures-util",
 ]
 
-[[package]]
-name = "futures-batch"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f444c45a1cb86f2a7e301469fd50a82084a60dadc25d94529a8312276ecb71a"
-dependencies = [
- "futures 0.3.31",
- "futures-timer",
- "pin-utils",
-]
-
 [[package]]
 name = "futures-channel"
 version = "0.3.31"
@@ -6269,12 +6232,6 @@ version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
 
-[[package]]
-name = "futures-timer"
-version = "3.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f288b0a4f20f9a56b5d1da57e2227c661b7b16168e2f72365f57b63326e29b24"
-
 [[package]]
 name = "futures-util"
 version = "0.3.31"
@@ -6412,7 +6369,7 @@ dependencies = [
  "log",
  "parking_lot",
  "pretty_assertions",
- "rand 0.8.5",
+ "rand 0.9.1",
  "regex",
  "rope",
  "schemars",
@@ -7465,7 +7422,7 @@ dependencies = [
  "pathfinder_geometry",
  "postage",
  "profiling",
- "rand 0.8.5",
+ "rand 0.9.1",
  "raw-window-handle",
  "refineable",
  "reqwest_client",
@@ -9078,7 +9035,7 @@ dependencies = [
  "parking_lot",
  "postage",
  "pretty_assertions",
- "rand 0.8.5",
+ "rand 0.9.1",
  "regex",
  "rpc",
  "schemars",
@@ -9220,6 +9177,19 @@ dependencies = [
  "x_ai",
 ]
 
+[[package]]
+name = "language_onboarding"
+version = "0.1.0"
+dependencies = [
+ "db",
+ "editor",
+ "gpui",
+ "project",
+ "ui",
+ "workspace",
+ "workspace-hack",
+]
+
 [[package]]
 name = "language_selector"
 version = "0.1.0"
@@ -9247,6 +9217,7 @@ dependencies = [
  "anyhow",
  "client",
  "collections",
+ "command_palette_hooks",
  "copilot",
  "editor",
  "futures 0.3.31",
@@ -9281,7 +9252,6 @@ dependencies = [
  "chrono",
  "collections",
  "dap",
- "feature_flags",
  "futures 0.3.31",
  "gpui",
  "http_client",
@@ -9517,6 +9487,21 @@ dependencies = [
  "vcpkg",
 ]
 
+[[package]]
+name = "line_ending_selector"
+version = "0.1.0"
+dependencies = [
+ "editor",
+ "gpui",
+ "language",
+ "picker",
+ "project",
+ "ui",
+ "util",
+ "workspace",
+ "workspace-hack",
+]
+
 [[package]]
 name = "link-cplusplus"
 version = "1.0.10"
@@ -10392,7 +10377,7 @@ dependencies = [
  "parking_lot",
  "pretty_assertions",
  "project",
- "rand 0.8.5",
+ "rand 0.9.1",
  "rope",
  "serde",
  "settings",
@@ -12618,12 +12603,13 @@ dependencies = [
  "postage",
  "prettier",
  "pretty_assertions",
- "rand 0.8.5",
+ "rand 0.9.1",
  "regex",
  "release_channel",
  "remote",
  "rpc",
  "schemars",
+ "semver",
  "serde",
  "serde_json",
  "settings",
@@ -12643,6 +12629,7 @@ dependencies = [
  "unindent",
  "url",
  "util",
+ "watch",
  "which 6.0.3",
  "workspace-hack",
  "worktree",
@@ -13892,7 +13879,7 @@ dependencies = [
  "ctor",
  "gpui",
  "log",
- "rand 0.8.5",
+ "rand 0.9.1",
  "rayon",
  "smallvec",
  "sum_tree",
@@ -13921,7 +13908,7 @@ dependencies = [
  "gpui",
  "parking_lot",
  "proto",
- "rand 0.8.5",
+ "rand 0.9.1",
  "rsa",
  "serde",
  "serde_json",
@@ -14356,6 +14343,19 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "scheduler"
+version = "0.1.0"
+dependencies = [
+ "async-task",
+ "chrono",
+ "futures 0.3.31",
+ "parking",
+ "parking_lot",
+ "rand 0.9.1",
+ "workspace-hack",
+]
+
 [[package]]
 name = "schema_generator"
 version = "0.1.0"
@@ -14658,49 +14658,6 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0f7d95a54511e0c7be3f51e8867aa8cf35148d7b9445d44de2f943e2b206e749"
 
-[[package]]
-name = "semantic_index"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "arrayvec",
- "blake3",
- "client",
- "clock",
- "collections",
- "feature_flags",
- "fs",
- "futures 0.3.31",
- "futures-batch",
- "gpui",
- "heed",
- "http_client",
- "language",
- "language_model",
- "languages",
- "log",
- "open_ai",
- "parking_lot",
- "project",
- "reqwest_client",
- "serde",
- "serde_json",
- "settings",
- "sha2",
- "smol",
- "streaming-iterator",
- "tempfile",
- "theme",
- "tree-sitter",
- "ui",
- "unindent",
- "util",
- "workspace",
- "workspace-hack",
- "worktree",
- "zlog",
-]
-
 [[package]]
 name = "semantic_version"
 version = "0.1.0"
@@ -15318,6 +15275,7 @@ dependencies = [
  "futures 0.3.31",
  "indoc",
  "libsqlite3-sys",
+ "log",
  "parking_lot",
  "smol",
  "sqlformat",
@@ -15655,7 +15613,7 @@ name = "streaming_diff"
 version = "0.1.0"
 dependencies = [
  "ordered-float 2.10.1",
- "rand 0.8.5",
+ "rand 0.9.1",
  "rope",
  "util",
  "workspace-hack",
@@ -15769,7 +15727,7 @@ dependencies = [
  "arrayvec",
  "ctor",
  "log",
- "rand 0.8.5",
+ "rand 0.9.1",
  "rayon",
  "workspace-hack",
  "zlog",
@@ -16360,7 +16318,7 @@ dependencies = [
  "futures 0.3.31",
  "gpui",
  "libc",
- "rand 0.8.5",
+ "rand 0.9.1",
  "regex",
  "release_channel",
  "schemars",
@@ -16408,7 +16366,7 @@ dependencies = [
  "language",
  "log",
  "project",
- "rand 0.8.5",
+ "rand 0.9.1",
  "regex",
  "schemars",
  "search",
@@ -16440,7 +16398,7 @@ dependencies = [
  "log",
  "parking_lot",
  "postage",
- "rand 0.8.5",
+ "rand 0.9.1",
  "regex",
  "rope",
  "smallvec",
@@ -16971,10 +16929,15 @@ checksum = "bfb942dfe1d8e29a7ee7fcbde5bd2b9a25fb89aa70caea2eba3bee836ff41076"
 name = "toolchain_selector"
 version = "0.1.0"
 dependencies = [
+ "anyhow",
+ "convert_case 0.8.0",
  "editor",
+ "file_finder",
+ "futures 0.3.31",
  "fuzzy",
  "gpui",
  "language",
+ "menu",
  "picker",
  "project",
  "ui",
@@ -17797,7 +17760,7 @@ dependencies = [
  "libc",
  "log",
  "nix 0.29.0",
- "rand 0.8.5",
+ "rand 0.9.1",
  "regex",
  "rust-embed",
  "schemars",
@@ -17982,6 +17945,8 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "gpui",
+ "schemars",
+ "serde",
  "settings",
  "workspace-hack",
 ]
@@ -18588,7 +18553,7 @@ dependencies = [
  "futures 0.3.31",
  "gpui",
  "parking_lot",
- "rand 0.8.5",
+ "rand 0.9.1",
  "workspace-hack",
  "zlog",
 ]
@@ -20047,7 +20012,7 @@ dependencies = [
  "paths",
  "postage",
  "pretty_assertions",
- "rand 0.8.5",
+ "rand 0.9.1",
  "rpc",
  "schemars",
  "serde",
@@ -20408,7 +20373,6 @@ dependencies = [
  "acp_tools",
  "activity_indicator",
  "agent",
- "agent_servers",
  "agent_settings",
  "agent_ui",
  "anyhow",
@@ -20472,10 +20436,12 @@ dependencies = [
  "language_extension",
  "language_model",
  "language_models",
+ "language_onboarding",
  "language_selector",
  "language_tools",
  "languages",
  "libc",
+ "line_ending_selector",
  "livekit_client",
  "log",
  "markdown",
@@ -20627,7 +20593,7 @@ dependencies = [
 
 [[package]]
 name = "zed_snippets"
-version = "0.0.5"
+version = "0.0.6"
 dependencies = [
  "serde_json",
  "zed_extension_api 0.1.0",
@@ -20640,13 +20606,6 @@ dependencies = [
  "zed_extension_api 0.6.0",
 ]
 
-[[package]]
-name = "zed_toml"
-version = "0.1.4"
-dependencies = [
- "zed_extension_api 0.1.0",
-]
-
 [[package]]
 name = "zeno"
 version = "0.3.2"
@@ -20810,9 +20769,10 @@ dependencies = [
  "language_model",
  "log",
  "menu",
+ "parking_lot",
  "postage",
  "project",
- "rand 0.8.5",
+ "rand 0.9.1",
  "regex",
  "release_channel",
  "reqwest_client",
@@ -20882,7 +20842,7 @@ dependencies = [
  "aes",
  "byteorder",
  "bzip2",
- "constant_time_eq 0.1.5",
+ "constant_time_eq",
  "crc32fast",
  "crossbeam-utils",
  "flate2",
diff --git a/Cargo.toml b/Cargo.toml
index 941c364e0dd85def66ebbc4e310ef0a90458fe44..0f13835f0c87b94c5acf335a63b0067d50fff156 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -94,9 +94,11 @@ members = [
     "crates/language_extension",
     "crates/language_model",
     "crates/language_models",
+    "crates/language_onboarding",
     "crates/language_selector",
     "crates/language_tools",
     "crates/languages",
+    "crates/line_ending_selector",
     "crates/livekit_api",
     "crates/livekit_client",
     "crates/lmstudio",
@@ -131,6 +133,7 @@ members = [
     "crates/refineable",
     "crates/refineable/derive_refineable",
     "crates/release_channel",
+    "crates/scheduler",
     "crates/remote",
     "crates/remote_server",
     "crates/repl",
@@ -141,7 +144,6 @@ members = [
     "crates/rules_library",
     "crates/schema_generator",
     "crates/search",
-    "crates/semantic_index",
     "crates/semantic_version",
     "crates/session",
     "crates/settings",
@@ -210,7 +212,6 @@ members = [
     "extensions/slash-commands-example",
     "extensions/snippets",
     "extensions/test-extension",
-    "extensions/toml",
 
     #
     # Tooling
@@ -320,9 +321,11 @@ language = { path = "crates/language" }
 language_extension = { path = "crates/language_extension" }
 language_model = { path = "crates/language_model" }
 language_models = { path = "crates/language_models" }
+language_onboarding = { path = "crates/language_onboarding" }
 language_selector = { path = "crates/language_selector" }
 language_tools = { path = "crates/language_tools" }
 languages = { path = "crates/languages" }
+line_ending_selector = { path = "crates/line_ending_selector" }
 livekit_api = { path = "crates/livekit_api" }
 livekit_client = { path = "crates/livekit_client" }
 lmstudio = { path = "crates/lmstudio" }
@@ -360,6 +363,7 @@ proto = { path = "crates/proto" }
 recent_projects = { path = "crates/recent_projects" }
 refineable = { path = "crates/refineable" }
 release_channel = { path = "crates/release_channel" }
+scheduler = { path = "crates/scheduler" }
 remote = { path = "crates/remote" }
 remote_server = { path = "crates/remote_server" }
 repl = { path = "crates/repl" }
@@ -370,7 +374,6 @@ rope = { path = "crates/rope" }
 rpc = { path = "crates/rpc" }
 rules_library = { path = "crates/rules_library" }
 search = { path = "crates/search" }
-semantic_index = { path = "crates/semantic_index" }
 semantic_version = { path = "crates/semantic_version" }
 session = { path = "crates/session" }
 settings = { path = "crates/settings" }
@@ -444,6 +447,7 @@ async-fs = "2.1"
 async-pipe = { git = "https://github.com/zed-industries/async-pipe-rs", rev = "82d00a04211cf4e1236029aa03e6b6ce2a74c553" }
 async-recursion = "1.0.0"
 async-tar = "0.5.0"
+async-task = "4.7"
 async-trait = "0.1"
 async-tungstenite = "0.29.1"
 async_zip = { version = "0.0.17", features = ["deflate", "deflate64"] }
@@ -459,9 +463,9 @@ aws-smithy-types = { version = "1.3.0", features = ["http-body-1-x"] }
 base64 = "0.22"
 bincode = "1.2.1"
 bitflags = "2.6.0"
-blade-graphics = { git = "https://github.com/kvark/blade", rev = "e0ec4e720957edd51b945b64dd85605ea54bcfe5" }
-blade-macros = { git = "https://github.com/kvark/blade", rev = "e0ec4e720957edd51b945b64dd85605ea54bcfe5" }
-blade-util = { git = "https://github.com/kvark/blade", rev = "e0ec4e720957edd51b945b64dd85605ea54bcfe5" }
+blade-graphics = { git = "https://github.com/kvark/blade", rev = "bfa594ea697d4b6326ea29f747525c85ecf933b9" }
+blade-macros = { git = "https://github.com/kvark/blade", rev = "bfa594ea697d4b6326ea29f747525c85ecf933b9" }
+blade-util = { git = "https://github.com/kvark/blade", rev = "bfa594ea697d4b6326ea29f747525c85ecf933b9" }
 blake3 = "1.5.3"
 bytes = "1.0"
 cargo_metadata = "0.19"
@@ -535,9 +539,35 @@ nbformat = {  git = "https://github.com/ConradIrwin/runtimed", rev = "7130c80421
 nix = "0.29"
 num-format = "0.4.4"
 objc = "0.2"
+objc2-foundation = { version = "0.3", default-features = false, features = [
+    "NSArray",
+    "NSAttributedString",
+    "NSBundle",
+    "NSCoder",
+    "NSData",
+    "NSDate",
+    "NSDictionary",
+    "NSEnumerator",
+    "NSError",
+    "NSGeometry",
+    "NSNotification",
+    "NSNull",
+    "NSObjCRuntime",
+    "NSObject",
+    "NSProcessInfo",
+    "NSRange",
+    "NSRunLoop",
+    "NSString",
+    "NSURL",
+    "NSUndoManager",
+    "NSValue",
+    "objc2-core-foundation",
+    "std"
+] }
 open = "5.0.0"
 ordered-float = "2.1.1"
 palette = { version = "0.7.5", default-features = false, features = ["std"] }
+parking = "2.0"
 parking_lot = "0.12.1"
 partial-json-fixer = "0.5.3"
 parse_int = "0.9"
@@ -560,7 +590,7 @@ prost-build = "0.9"
 prost-types = "0.9"
 pulldown-cmark = { version = "0.12.0", default-features = false }
 quote = "1.0.9"
-rand = "0.8.5"
+rand = "0.9"
 rayon = "1.8"
 ref-cast = "1.0.24"
 regex = "1.5"
diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json
index 28518490ccbe9d3a4e8161ffbc32ed5c27ae0d84..ac44b3f1ae55feb11b0027efea14c6afed8cb62a 100644
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -16,6 +16,7 @@
       "up": "menu::SelectPrevious",
       "enter": "menu::Confirm",
       "ctrl-enter": "menu::SecondaryConfirm",
+      "ctrl-escape": "menu::Cancel",
       "ctrl-c": "menu::Cancel",
       "escape": "menu::Cancel",
       "alt-shift-enter": "menu::Restart",
@@ -582,7 +583,7 @@
       "ctrl-n": "workspace::NewFile",
       "shift-new": "workspace::NewWindow",
       "ctrl-shift-n": "workspace::NewWindow",
-      "ctrl-`": "terminal_panel::ToggleFocus",
+      "ctrl-`": "terminal_panel::Toggle",
       "f10": ["app_menu::OpenApplicationMenu", "Zed"],
       "alt-1": ["workspace::ActivatePane", 0],
       "alt-2": ["workspace::ActivatePane", 1],
@@ -627,6 +628,7 @@
       "alt-save": "workspace::SaveAll",
       "ctrl-alt-s": "workspace::SaveAll",
       "ctrl-k m": "language_selector::Toggle",
+      "ctrl-k ctrl-m": "toolchain::AddToolchain",
       "escape": "workspace::Unfollow",
       "ctrl-k ctrl-left": "workspace::ActivatePaneLeft",
       "ctrl-k ctrl-right": "workspace::ActivatePaneRight",
@@ -1027,6 +1029,13 @@
       "tab": "channel_modal::ToggleMode"
     }
   },
+  {
+    "context": "ToolchainSelector",
+    "use_key_equivalents": true,
+    "bindings": {
+      "ctrl-shift-a": "toolchain::AddToolchain"
+    }
+  },
   {
     "context": "FileFinder || (FileFinder > Picker > Editor)",
     "bindings": {
diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json
index 954684c826b18828857c6411e2413aa514aeec45..337915527ca22f04afc8450cf6a366d1f2995551 100644
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -649,7 +649,7 @@
       "alt-shift-enter": "toast::RunAction",
       "cmd-shift-s": "workspace::SaveAs",
       "cmd-shift-n": "workspace::NewWindow",
-      "ctrl-`": "terminal_panel::ToggleFocus",
+      "ctrl-`": "terminal_panel::Toggle",
       "cmd-1": ["workspace::ActivatePane", 0],
       "cmd-2": ["workspace::ActivatePane", 1],
       "cmd-3": ["workspace::ActivatePane", 2],
@@ -690,6 +690,7 @@
       "cmd-?": "agent::ToggleFocus",
       "cmd-alt-s": "workspace::SaveAll",
       "cmd-k m": "language_selector::Toggle",
+      "cmd-k cmd-m": "toolchain::AddToolchain",
       "escape": "workspace::Unfollow",
       "cmd-k cmd-left": "workspace::ActivatePaneLeft",
       "cmd-k cmd-right": "workspace::ActivatePaneRight",
@@ -1094,6 +1095,13 @@
       "tab": "channel_modal::ToggleMode"
     }
   },
+  {
+    "context": "ToolchainSelector",
+    "use_key_equivalents": true,
+    "bindings": {
+      "cmd-shift-a": "toolchain::AddToolchain"
+    }
+  },
   {
     "context": "FileFinder || (FileFinder > Picker > Editor)",
     "use_key_equivalents": true,
diff --git a/assets/keymaps/default-windows.json b/assets/keymaps/default-windows.json
index 728907e60ca3361270f15b20f66aaf7571be6ac2..de0d97b52e2b0fe9bac931cb46debc812a56a70b 100644
--- a/assets/keymaps/default-windows.json
+++ b/assets/keymaps/default-windows.json
@@ -25,7 +25,6 @@
       "ctrl-alt-enter": ["picker::ConfirmInput", { "secondary": true }],
       "ctrl-shift-w": "workspace::CloseWindow",
       "shift-escape": "workspace::ToggleZoom",
-      "open": "workspace::Open",
       "ctrl-o": "workspace::Open",
       "ctrl-=": ["zed::IncreaseBufferFontSize", { "persist": false }],
       "ctrl-shift-=": ["zed::IncreaseBufferFontSize", { "persist": false }],
@@ -68,18 +67,13 @@
       "ctrl-k q": "editor::Rewrap",
       "ctrl-backspace": ["editor::DeleteToPreviousWordStart", { "ignore_newlines": false, "ignore_brackets": false }],
       "ctrl-delete": ["editor::DeleteToNextWordEnd", { "ignore_newlines": false, "ignore_brackets": false }],
-      "cut": "editor::Cut",
       "shift-delete": "editor::Cut",
       "ctrl-x": "editor::Cut",
-      "copy": "editor::Copy",
       "ctrl-insert": "editor::Copy",
       "ctrl-c": "editor::Copy",
-      "paste": "editor::Paste",
       "shift-insert": "editor::Paste",
       "ctrl-v": "editor::Paste",
-      "undo": "editor::Undo",
       "ctrl-z": "editor::Undo",
-      "redo": "editor::Redo",
       "ctrl-y": "editor::Redo",
       "ctrl-shift-z": "editor::Redo",
       "up": "editor::MoveUp",
@@ -138,7 +132,6 @@
       "ctrl-shift-enter": "editor::NewlineAbove",
       "ctrl-k ctrl-z": "editor::ToggleSoftWrap",
       "ctrl-k z": "editor::ToggleSoftWrap",
-      "find": "buffer_search::Deploy",
       "ctrl-f": "buffer_search::Deploy",
       "ctrl-h": "buffer_search::DeployReplace",
       "ctrl-shift-.": "assistant::QuoteSelection",
@@ -177,7 +170,6 @@
     "context": "Markdown",
     "use_key_equivalents": true,
     "bindings": {
-      "copy": "markdown::Copy",
       "ctrl-c": "markdown::Copy"
     }
   },
@@ -225,7 +217,6 @@
     "bindings": {
       "ctrl-enter": "assistant::Assist",
       "ctrl-s": "workspace::Save",
-      "save": "workspace::Save",
       "ctrl-shift-,": "assistant::InsertIntoEditor",
       "shift-enter": "assistant::Split",
       "ctrl-r": "assistant::CycleMessageRole",
@@ -272,7 +263,6 @@
     "context": "AgentPanel > Markdown",
     "use_key_equivalents": true,
     "bindings": {
-      "copy": "markdown::CopyAsMarkdown",
       "ctrl-c": "markdown::CopyAsMarkdown"
     }
   },
@@ -367,7 +357,6 @@
     "context": "PromptLibrary",
     "use_key_equivalents": true,
     "bindings": {
-      "new": "rules_library::NewRule",
       "ctrl-n": "rules_library::NewRule",
       "ctrl-shift-s": "rules_library::ToggleDefaultRule"
     }
@@ -381,7 +370,6 @@
       "enter": "search::SelectNextMatch",
       "shift-enter": "search::SelectPreviousMatch",
       "alt-enter": "search::SelectAllMatches",
-      "find": "search::FocusSearch",
       "ctrl-f": "search::FocusSearch",
       "ctrl-h": "search::ToggleReplace",
       "ctrl-l": "search::ToggleSelection"
@@ -408,7 +396,6 @@
     "use_key_equivalents": true,
     "bindings": {
       "escape": "project_search::ToggleFocus",
-      "shift-find": "search::FocusSearch",
       "ctrl-shift-f": "search::FocusSearch",
       "ctrl-shift-h": "search::ToggleReplace",
       "alt-r": "search::ToggleRegex" // vscode
@@ -472,14 +459,12 @@
       "forward": "pane::GoForward",
       "f3": "search::SelectNextMatch",
       "shift-f3": "search::SelectPreviousMatch",
-      "shift-find": "project_search::ToggleFocus",
       "ctrl-shift-f": "project_search::ToggleFocus",
       "shift-alt-h": "search::ToggleReplace",
       "alt-l": "search::ToggleSelection",
       "alt-enter": "search::SelectAllMatches",
       "alt-c": "search::ToggleCaseSensitive",
       "alt-w": "search::ToggleWholeWord",
-      "alt-find": "project_search::ToggleFilters",
       "alt-f": "project_search::ToggleFilters",
       "alt-r": "search::ToggleRegex",
       // "ctrl-shift-alt-x": "search::ToggleRegex",
@@ -579,27 +564,21 @@
     "context": "Workspace",
     "use_key_equivalents": true,
     "bindings": {
-      "alt-open": ["projects::OpenRecent", { "create_new_window": false }],
       // Change the default action on `menu::Confirm` by setting the parameter
       // "ctrl-alt-o": ["projects::OpenRecent", { "create_new_window": true }],
       "ctrl-r": ["projects::OpenRecent", { "create_new_window": false }],
-      "shift-alt-open": ["projects::OpenRemote", { "from_existing_connection": false, "create_new_window": false }],
       // Change to open path modal for existing remote connection by setting the parameter
       // "ctrl-shift-alt-o": "["projects::OpenRemote", { "from_existing_connection": true }]",
       "ctrl-shift-alt-o": ["projects::OpenRemote", { "from_existing_connection": false, "create_new_window": false }],
       "shift-alt-b": "branches::OpenRecent",
       "shift-alt-enter": "toast::RunAction",
       "ctrl-shift-`": "workspace::NewTerminal",
-      "save": "workspace::Save",
       "ctrl-s": "workspace::Save",
       "ctrl-k ctrl-shift-s": "workspace::SaveWithoutFormat",
-      "shift-save": "workspace::SaveAs",
       "ctrl-shift-s": "workspace::SaveAs",
-      "new": "workspace::NewFile",
       "ctrl-n": "workspace::NewFile",
-      "shift-new": "workspace::NewWindow",
       "ctrl-shift-n": "workspace::NewWindow",
-      "ctrl-`": "terminal_panel::ToggleFocus",
+      "ctrl-`": "terminal_panel::Toggle",
       "f10": ["app_menu::OpenApplicationMenu", "Zed"],
       "alt-1": ["workspace::ActivatePane", 0],
       "alt-2": ["workspace::ActivatePane", 1],
@@ -621,7 +600,6 @@
       "shift-alt-0": "workspace::ResetOpenDocksSize",
       "ctrl-shift-alt--": ["workspace::DecreaseOpenDocksSize", { "px": 0 }],
       "ctrl-shift-alt-=": ["workspace::IncreaseOpenDocksSize", { "px": 0 }],
-      "shift-find": "pane::DeploySearch",
       "ctrl-shift-f": "pane::DeploySearch",
       "ctrl-shift-h": ["pane::DeploySearch", { "replace_enabled": true }],
       "ctrl-shift-t": "pane::ReopenClosedItem",
@@ -641,9 +619,9 @@
       "ctrl-shift-g": "git_panel::ToggleFocus",
       "ctrl-shift-d": "debug_panel::ToggleFocus",
       "ctrl-shift-/": "agent::ToggleFocus",
-      "alt-save": "workspace::SaveAll",
       "ctrl-k s": "workspace::SaveAll",
       "ctrl-k m": "language_selector::Toggle",
+      "ctrl-m ctrl-m": "toolchain::AddToolchain",
       "escape": "workspace::Unfollow",
       "ctrl-k ctrl-left": "workspace::ActivatePaneLeft",
       "ctrl-k ctrl-right": "workspace::ActivatePaneRight",
@@ -848,9 +826,7 @@
     "bindings": {
       "left": "outline_panel::CollapseSelectedEntry",
       "right": "outline_panel::ExpandSelectedEntry",
-      "alt-copy": "outline_panel::CopyPath",
       "shift-alt-c": "outline_panel::CopyPath",
-      "shift-alt-copy": "workspace::CopyRelativePath",
       "ctrl-shift-alt-c": "workspace::CopyRelativePath",
       "ctrl-alt-r": "outline_panel::RevealInFileManager",
       "space": "outline_panel::OpenSelectedEntry",
@@ -866,21 +842,14 @@
     "bindings": {
       "left": "project_panel::CollapseSelectedEntry",
       "right": "project_panel::ExpandSelectedEntry",
-      "new": "project_panel::NewFile",
       "ctrl-n": "project_panel::NewFile",
-      "alt-new": "project_panel::NewDirectory",
       "alt-n": "project_panel::NewDirectory",
-      "cut": "project_panel::Cut",
       "ctrl-x": "project_panel::Cut",
-      "copy": "project_panel::Copy",
       "ctrl-insert": "project_panel::Copy",
       "ctrl-c": "project_panel::Copy",
-      "paste": "project_panel::Paste",
       "shift-insert": "project_panel::Paste",
       "ctrl-v": "project_panel::Paste",
-      "alt-copy": "project_panel::CopyPath",
       "shift-alt-c": "project_panel::CopyPath",
-      "shift-alt-copy": "workspace::CopyRelativePath",
       "ctrl-k ctrl-shift-c": "workspace::CopyRelativePath",
       "enter": "project_panel::Rename",
       "f2": "project_panel::Rename",
@@ -892,7 +861,6 @@
       "ctrl-alt-r": "project_panel::RevealInFileManager",
       "ctrl-shift-enter": "project_panel::OpenWithSystem",
       "alt-d": "project_panel::CompareMarkedFiles",
-      "shift-find": "project_panel::NewSearchInDirectory",
       "ctrl-k ctrl-shift-f": "project_panel::NewSearchInDirectory",
       "shift-down": "menu::SelectNext",
       "shift-up": "menu::SelectPrevious",
@@ -1075,6 +1043,13 @@
       "tab": "channel_modal::ToggleMode"
     }
   },
+  {
+    "context": "ToolchainSelector",
+    "use_key_equivalents": true,
+    "bindings": {
+      "ctrl-shift-a": "toolchain::AddToolchain"
+    }
+  },
   {
     "context": "FileFinder || (FileFinder > Picker > Editor)",
     "use_key_equivalents": true,
@@ -1110,10 +1085,8 @@
     "use_key_equivalents": true,
     "bindings": {
       "ctrl-alt-space": "terminal::ShowCharacterPalette",
-      "copy": "terminal::Copy",
       "ctrl-insert": "terminal::Copy",
       "ctrl-shift-c": "terminal::Copy",
-      "paste": "terminal::Paste",
       "shift-insert": "terminal::Paste",
       "ctrl-shift-v": "terminal::Paste",
       "ctrl-enter": "assistant::InlineAssist",
@@ -1129,7 +1102,6 @@
       "ctrl-w": ["terminal::SendKeystroke", "ctrl-w"],
       "ctrl-backspace": ["terminal::SendKeystroke", "ctrl-w"],
       "ctrl-shift-a": "editor::SelectAll",
-      "find": "buffer_search::Deploy",
       "ctrl-shift-f": "buffer_search::Deploy",
       "ctrl-shift-l": "terminal::Clear",
       "ctrl-shift-w": "pane::CloseActiveItem",
@@ -1210,7 +1182,6 @@
     "use_key_equivalents": true,
     "bindings": {
       "ctrl-f": "search::FocusSearch",
-      "alt-find": "keymap_editor::ToggleKeystrokeSearch",
       "alt-f": "keymap_editor::ToggleKeystrokeSearch",
       "alt-c": "keymap_editor::ToggleConflictFilter",
       "enter": "keymap_editor::EditBinding",
diff --git a/assets/keymaps/linux/jetbrains.json b/assets/keymaps/linux/jetbrains.json
index 3df1243feda88680a4ce03cd0b25ab9ea9a36edd..59a182a968a849edb3359927e7647f611bcd44da 100644
--- a/assets/keymaps/linux/jetbrains.json
+++ b/assets/keymaps/linux/jetbrains.json
@@ -125,7 +125,7 @@
   {
     "context": "Workspace || Editor",
     "bindings": {
-      "alt-f12": "terminal_panel::ToggleFocus",
+      "alt-f12": "terminal_panel::Toggle",
       "ctrl-shift-k": "git::Push"
     }
   },
diff --git a/assets/keymaps/macos/jetbrains.json b/assets/keymaps/macos/jetbrains.json
index 66962811f48a429f2f5d036241c64d6549f60334..2c757c3a30a08eb55e8344945ab66baf91ce0c6b 100644
--- a/assets/keymaps/macos/jetbrains.json
+++ b/assets/keymaps/macos/jetbrains.json
@@ -127,7 +127,7 @@
   {
     "context": "Workspace || Editor",
     "bindings": {
-      "alt-f12": "terminal_panel::ToggleFocus",
+      "alt-f12": "terminal_panel::Toggle",
       "cmd-shift-k": "git::Push"
     }
   },
diff --git a/assets/keymaps/vim.json b/assets/keymaps/vim.json
index fa7f82e1032ead9cb1f1ce12f3484602954123ca..508d8949d2e38bfcf324ad611461d7077621a301 100644
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -32,34 +32,6 @@
       "(": "vim::SentenceBackward",
       ")": "vim::SentenceForward",
       "|": "vim::GoToColumn",
-      "] ]": "vim::NextSectionStart",
-      "] [": "vim::NextSectionEnd",
-      "[ [": "vim::PreviousSectionStart",
-      "[ ]": "vim::PreviousSectionEnd",
-      "] m": "vim::NextMethodStart",
-      "] shift-m": "vim::NextMethodEnd",
-      "[ m": "vim::PreviousMethodStart",
-      "[ shift-m": "vim::PreviousMethodEnd",
-      "[ *": "vim::PreviousComment",
-      "[ /": "vim::PreviousComment",
-      "] *": "vim::NextComment",
-      "] /": "vim::NextComment",
-      "[ -": "vim::PreviousLesserIndent",
-      "[ +": "vim::PreviousGreaterIndent",
-      "[ =": "vim::PreviousSameIndent",
-      "] -": "vim::NextLesserIndent",
-      "] +": "vim::NextGreaterIndent",
-      "] =": "vim::NextSameIndent",
-      "] b": "pane::ActivateNextItem",
-      "[ b": "pane::ActivatePreviousItem",
-      "] shift-b": "pane::ActivateLastItem",
-      "[ shift-b": ["pane::ActivateItem", 0],
-      "] space": "vim::InsertEmptyLineBelow",
-      "[ space": "vim::InsertEmptyLineAbove",
-      "[ e": "editor::MoveLineUp",
-      "] e": "editor::MoveLineDown",
-      "[ f": "workspace::FollowNextCollaborator",
-      "] f": "workspace::FollowNextCollaborator",
 
       // Word motions
       "w": "vim::NextWordStart",
@@ -83,10 +55,6 @@
       "n": "vim::MoveToNextMatch",
       "shift-n": "vim::MoveToPreviousMatch",
       "%": "vim::Matching",
-      "] }": ["vim::UnmatchedForward", { "char": "}" }],
-      "[ {": ["vim::UnmatchedBackward", { "char": "{" }],
-      "] )": ["vim::UnmatchedForward", { "char": ")" }],
-      "[ (": ["vim::UnmatchedBackward", { "char": "(" }],
       "f": ["vim::PushFindForward", { "before": false, "multiline": false }],
       "t": ["vim::PushFindForward", { "before": true, "multiline": false }],
       "shift-f": ["vim::PushFindBackward", { "after": false, "multiline": false }],
@@ -219,6 +187,46 @@
       ".": "vim::Repeat"
     }
   },
+  {
+    "context": "vim_mode == normal || vim_mode == visual || vim_mode == operator",
+    "bindings": {
+      "] ]": "vim::NextSectionStart",
+      "] [": "vim::NextSectionEnd",
+      "[ [": "vim::PreviousSectionStart",
+      "[ ]": "vim::PreviousSectionEnd",
+      "] m": "vim::NextMethodStart",
+      "] shift-m": "vim::NextMethodEnd",
+      "[ m": "vim::PreviousMethodStart",
+      "[ shift-m": "vim::PreviousMethodEnd",
+      "[ *": "vim::PreviousComment",
+      "[ /": "vim::PreviousComment",
+      "] *": "vim::NextComment",
+      "] /": "vim::NextComment",
+      "[ -": "vim::PreviousLesserIndent",
+      "[ +": "vim::PreviousGreaterIndent",
+      "[ =": "vim::PreviousSameIndent",
+      "] -": "vim::NextLesserIndent",
+      "] +": "vim::NextGreaterIndent",
+      "] =": "vim::NextSameIndent",
+      "] b": "pane::ActivateNextItem",
+      "[ b": "pane::ActivatePreviousItem",
+      "] shift-b": "pane::ActivateLastItem",
+      "[ shift-b": ["pane::ActivateItem", 0],
+      "] space": "vim::InsertEmptyLineBelow",
+      "[ space": "vim::InsertEmptyLineAbove",
+      "[ e": "editor::MoveLineUp",
+      "] e": "editor::MoveLineDown",
+      "[ f": "workspace::FollowNextCollaborator",
+      "] f": "workspace::FollowNextCollaborator",
+      "] }": ["vim::UnmatchedForward", { "char": "}" }],
+      "[ {": ["vim::UnmatchedBackward", { "char": "{" }],
+      "] )": ["vim::UnmatchedForward", { "char": ")" }],
+      "[ (": ["vim::UnmatchedBackward", { "char": "(" }],
+      // tree-sitter related commands
+      "[ x": "vim::SelectLargerSyntaxNode",
+      "] x": "vim::SelectSmallerSyntaxNode"
+    }
+  },
   {
     "context": "vim_mode == normal",
     "bindings": {
@@ -249,9 +257,6 @@
       "g w": "vim::PushRewrap",
       "g q": "vim::PushRewrap",
       "insert": "vim::InsertBefore",
-      // tree-sitter related commands
-      "[ x": "vim::SelectLargerSyntaxNode",
-      "] x": "vim::SelectSmallerSyntaxNode",
       "] d": "editor::GoToDiagnostic",
       "[ d": "editor::GoToPreviousDiagnostic",
       "] c": "editor::GoToHunk",
@@ -317,10 +322,7 @@
       "g w": "vim::Rewrap",
       "g ?": "vim::ConvertToRot13",
       // "g ?": "vim::ConvertToRot47",
-      "\"": "vim::PushRegister",
-      // tree-sitter related commands
-      "[ x": "editor::SelectLargerSyntaxNode",
-      "] x": "editor::SelectSmallerSyntaxNode"
+      "\"": "vim::PushRegister"
     }
   },
   {
@@ -397,6 +399,9 @@
       "ctrl-[": "editor::Cancel",
       ";": "vim::HelixCollapseSelection",
       ":": "command_palette::Toggle",
+      "m": "vim::PushHelixMatch",
+      "]": ["vim::PushHelixNext", { "around": true }],
+      "[": ["vim::PushHelixPrevious", { "around": true }],
       "left": "vim::WrappingLeft",
       "right": "vim::WrappingRight",
       "h": "vim::WrappingLeft",
@@ -419,13 +424,6 @@
       "insert": "vim::InsertBefore",
       "alt-.": "vim::RepeatFind",
       "alt-s": ["editor::SplitSelectionIntoLines", { "keep_selections": true }],
-      // tree-sitter related commands
-      "[ x": "editor::SelectLargerSyntaxNode",
-      "] x": "editor::SelectSmallerSyntaxNode",
-      "] d": "editor::GoToDiagnostic",
-      "[ d": "editor::GoToPreviousDiagnostic",
-      "] c": "editor::GoToHunk",
-      "[ c": "editor::GoToPreviousHunk",
       // Goto mode
       "g n": "pane::ActivateNextItem",
       "g p": "pane::ActivatePreviousItem",
@@ -469,9 +467,6 @@
       "space c": "editor::ToggleComments",
       "space y": "editor::Copy",
       "space p": "editor::Paste",
-      // Match mode
-      "m m": "vim::Matching",
-      "m i w": ["workspace::SendKeystrokes", "v i w"],
       "shift-u": "editor::Redo",
       "ctrl-c": "editor::ToggleComments",
       "d": "vim::HelixDelete",
@@ -540,7 +535,7 @@
     }
   },
   {
-    "context": "vim_operator == a || vim_operator == i || vim_operator == cs",
+    "context": "vim_operator == a || vim_operator == i || vim_operator == cs || vim_operator == helix_next || vim_operator == helix_previous",
     "bindings": {
       "w": "vim::Word",
       "shift-w": ["vim::Word", { "ignore_punctuation": true }],
@@ -577,6 +572,48 @@
       "e": "vim::EntireFile"
     }
   },
+  {
+    "context": "vim_operator == helix_m",
+    "bindings": {
+      "m": "vim::Matching"
+    }
+  },
+  {
+    "context": "vim_operator == helix_next",
+    "bindings": {
+      "z": "vim::NextSectionStart",
+      "shift-z": "vim::NextSectionEnd",
+      "*": "vim::NextComment",
+      "/": "vim::NextComment",
+      "-": "vim::NextLesserIndent",
+      "+": "vim::NextGreaterIndent",
+      "=": "vim::NextSameIndent",
+      "b": "pane::ActivateNextItem",
+      "shift-b": "pane::ActivateLastItem",
+      "x": "editor::SelectSmallerSyntaxNode",
+      "d": "editor::GoToDiagnostic",
+      "c": "editor::GoToHunk",
+      "space": "vim::InsertEmptyLineBelow"
+    }
+  },
+  {
+    "context": "vim_operator == helix_previous",
+    "bindings": {
+      "z": "vim::PreviousSectionStart",
+      "shift-z": "vim::PreviousSectionEnd",
+      "*": "vim::PreviousComment",
+      "/": "vim::PreviousComment",
+      "-": "vim::PreviousLesserIndent",
+      "+": "vim::PreviousGreaterIndent",
+      "=": "vim::PreviousSameIndent",
+      "b": "pane::ActivatePreviousItem",
+      "shift-b": ["pane::ActivateItem", 0],
+      "x": "editor::SelectLargerSyntaxNode",
+      "d": "editor::GoToPreviousDiagnostic",
+      "c": "editor::GoToPreviousHunk",
+      "space": "vim::InsertEmptyLineAbove"
+    }
+  },
   {
     "context": "vim_operator == c",
     "bindings": {
diff --git a/assets/settings/default.json b/assets/settings/default.json
index 0b5481bd4e4e2177302e38199bb66e87471d2904..2f04687925374992bbea42e13218e52635ec23a5 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -740,16 +740,6 @@
     // Default width of the collaboration panel.
     "default_width": 240
   },
-  "chat_panel": {
-    // When to show the chat panel button in the status bar.
-    // Can be 'never', 'always', or 'when_in_call',
-    // or a boolean (interpreted as 'never'/'always').
-    "button": "when_in_call",
-    // Where to dock the chat panel. Can be 'left' or 'right'.
-    "dock": "right",
-    // Default width of the chat panel.
-    "default_width": 240
-  },
   "git_panel": {
     // Whether to show the git panel button in the status bar.
     "button": true,
@@ -962,7 +952,7 @@
     // Show git status colors in the editor tabs.
     "git_status": false,
     // Position of the close button on the editor tabs.
-    // One of: ["right", "left", "hidden"]
+    // One of: ["right", "left"]
     "close_position": "right",
     // Whether to show the file icon for a tab.
     "file_icons": false,
diff --git a/crates/acp_thread/src/acp_thread.rs b/crates/acp_thread/src/acp_thread.rs
index dc295369cce2b8fda596e3917724187bd35b7377..f36ed6e7a04876dcb057f87889c6c224934681bc 100644
--- a/crates/acp_thread/src/acp_thread.rs
+++ b/crates/acp_thread/src/acp_thread.rs
@@ -1640,13 +1640,13 @@ impl AcpThread {
         cx.foreground_executor().spawn(send_task)
     }
 
-    /// Rewinds this thread to before the entry at `index`, removing it and all
-    /// subsequent entries while reverting any changes made from that point.
-    pub fn rewind(&mut self, id: UserMessageId, cx: &mut Context<Self>) -> Task<Result<()>> {
-        let Some(truncate) = self.connection.truncate(&self.session_id, cx) else {
-            return Task::ready(Err(anyhow!("not supported")));
-        };
-        let Some(message) = self.user_message(&id) else {
+    /// Restores the git working tree to the state at the given checkpoint (if one exists)
+    pub fn restore_checkpoint(
+        &mut self,
+        id: UserMessageId,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        let Some((_, message)) = self.user_message_mut(&id) else {
             return Task::ready(Err(anyhow!("message not found")));
         };
 
@@ -1654,15 +1654,30 @@ impl AcpThread {
             .checkpoint
             .as_ref()
             .map(|c| c.git_checkpoint.clone());
-
+        let rewind = self.rewind(id.clone(), cx);
         let git_store = self.project.read(cx).git_store().clone();
-        cx.spawn(async move |this, cx| {
+
+        cx.spawn(async move |_, cx| {
+            rewind.await?;
             if let Some(checkpoint) = checkpoint {
                 git_store
                     .update(cx, |git, cx| git.restore_checkpoint(checkpoint, cx))?
                     .await?;
             }
 
+            Ok(())
+        })
+    }
+
+    /// Rewinds this thread to before the entry at `index`, removing it and all
+    /// subsequent entries while rejecting any action_log changes made from that point.
+    /// Unlike `restore_checkpoint`, this method does not restore from git.
+    pub fn rewind(&mut self, id: UserMessageId, cx: &mut Context<Self>) -> Task<Result<()>> {
+        let Some(truncate) = self.connection.truncate(&self.session_id, cx) else {
+            return Task::ready(Err(anyhow!("not supported")));
+        };
+
+        cx.spawn(async move |this, cx| {
             cx.update(|cx| truncate.run(id.clone(), cx))?.await?;
             this.update(cx, |this, cx| {
                 if let Some((ix, _)) = this.user_message_mut(&id) {
@@ -1670,7 +1685,11 @@ impl AcpThread {
                     this.entries.truncate(ix);
                     cx.emit(AcpThreadEvent::EntriesRemoved(range));
                 }
-            })
+                this.action_log()
+                    .update(cx, |action_log, cx| action_log.reject_all_edits(cx))
+            })?
+            .await;
+            Ok(())
         })
     }
 
@@ -1727,20 +1746,6 @@ impl AcpThread {
             })
     }
 
-    fn user_message(&self, id: &UserMessageId) -> Option<&UserMessage> {
-        self.entries.iter().find_map(|entry| {
-            if let AgentThreadEntry::UserMessage(message) = entry {
-                if message.id.as_ref() == Some(id) {
-                    Some(message)
-                } else {
-                    None
-                }
-            } else {
-                None
-            }
-        })
-    }
-
     fn user_message_mut(&mut self, id: &UserMessageId) -> Option<(usize, &mut UserMessage)> {
         self.entries.iter_mut().enumerate().find_map(|(ix, entry)| {
             if let AgentThreadEntry::UserMessage(message) = entry {
@@ -2114,7 +2119,7 @@ mod tests {
     use gpui::{App, AsyncApp, TestAppContext, WeakEntity};
     use indoc::indoc;
     use project::{FakeFs, Fs};
-    use rand::Rng as _;
+    use rand::{distr, prelude::*};
     use serde_json::json;
     use settings::SettingsStore;
     use smol::stream::StreamExt as _;
@@ -2684,7 +2689,7 @@ mod tests {
                 let AgentThreadEntry::UserMessage(message) = &thread.entries[2] else {
                     panic!("unexpected entries {:?}", thread.entries)
                 };
-                thread.rewind(message.id.clone().unwrap(), cx)
+                thread.restore_checkpoint(message.id.clone().unwrap(), cx)
             })
             .await
             .unwrap();
@@ -2758,7 +2763,7 @@ mod tests {
         }));
 
         let thread = cx
-            .update(|cx| connection.new_thread(project, Path::new("/test"), cx))
+            .update(|cx| connection.new_thread(project, Path::new(path!("/test")), cx))
             .await
             .unwrap();
 
@@ -3057,8 +3062,8 @@ mod tests {
             cx: &mut App,
         ) -> Task<gpui::Result<Entity<AcpThread>>> {
             let session_id = acp::SessionId(
-                rand::thread_rng()
-                    .sample_iter(&rand::distributions::Alphanumeric)
+                rand::rng()
+                    .sample_iter(&distr::Alphanumeric)
                     .take(7)
                     .map(char::from)
                     .collect::<String>()
diff --git a/crates/action_log/src/action_log.rs b/crates/action_log/src/action_log.rs
index 9ec10f4dbb0e670bf20d9c033db9cec02e5fda67..11ba596ac5a0ecd4ed49744d0eafa9defcde20c1 100644
--- a/crates/action_log/src/action_log.rs
+++ b/crates/action_log/src/action_log.rs
@@ -2218,7 +2218,7 @@ mod tests {
         action_log.update(cx, |log, cx| log.buffer_read(buffer.clone(), cx));
 
         for _ in 0..operations {
-            match rng.gen_range(0..100) {
+            match rng.random_range(0..100) {
                 0..25 => {
                     action_log.update(cx, |log, cx| {
                         let range = buffer.read(cx).random_byte_range(0, &mut rng);
@@ -2237,7 +2237,7 @@ mod tests {
                         .unwrap();
                 }
                 _ => {
-                    let is_agent_edit = rng.gen_bool(0.5);
+                    let is_agent_edit = rng.random_bool(0.5);
                     if is_agent_edit {
                         log::info!("agent edit");
                     } else {
@@ -2252,7 +2252,7 @@ mod tests {
                 }
             }
 
-            if rng.gen_bool(0.2) {
+            if rng.random_bool(0.2) {
                 quiesce(&action_log, &buffer, cx);
             }
         }
diff --git a/crates/activity_indicator/src/activity_indicator.rs b/crates/activity_indicator/src/activity_indicator.rs
index 1f4c10b060aebfaf4931cda1020c3ca8cc9cf79f..1870ab74db214b518bb0b543166067e636f14965 100644
--- a/crates/activity_indicator/src/activity_indicator.rs
+++ b/crates/activity_indicator/src/activity_indicator.rs
@@ -212,7 +212,8 @@ impl ActivityIndicator {
                 server_name,
                 status,
             } => {
-                let create_buffer = project.update(cx, |project, cx| project.create_buffer(cx));
+                let create_buffer =
+                    project.update(cx, |project, cx| project.create_buffer(false, cx));
                 let status = status.clone();
                 let server_name = server_name.clone();
                 cx.spawn_in(window, async move |workspace, cx| {
diff --git a/crates/agent2/src/native_agent_server.rs b/crates/agent2/src/native_agent_server.rs
index 030d2cce746970bd9c8a0c7f0f5e1516eb68fcaf..0dde0ff98552d4292a4391d2aec4f36419228a25 100644
--- a/crates/agent2/src/native_agent_server.rs
+++ b/crates/agent2/src/native_agent_server.rs
@@ -35,10 +35,15 @@ impl AgentServer for NativeAgentServer {
 
     fn connect(
         &self,
-        _root_dir: &Path,
+        _root_dir: Option<&Path>,
         delegate: AgentServerDelegate,
         cx: &mut App,
-    ) -> Task<Result<Rc<dyn acp_thread::AgentConnection>>> {
+    ) -> Task<
+        Result<(
+            Rc<dyn acp_thread::AgentConnection>,
+            Option<task::SpawnInTerminal>,
+        )>,
+    > {
         log::debug!(
             "NativeAgentServer::connect called for path: {:?}",
             _root_dir
@@ -60,7 +65,10 @@ impl AgentServer for NativeAgentServer {
             let connection = NativeAgentConnection(agent);
             log::debug!("NativeAgentServer connection established successfully");
 
-            Ok(Rc::new(connection) as Rc<dyn acp_thread::AgentConnection>)
+            Ok((
+                Rc::new(connection) as Rc<dyn acp_thread::AgentConnection>,
+                None,
+            ))
         })
     }
 
diff --git a/crates/agent2/src/tests/test_tools.rs b/crates/agent2/src/tests/test_tools.rs
index 27be7b6ac384219cdd06e6dc971078c3ff0b9a7b..2275d23c2f8a924efce2d2d4d8bcf6a6f3a59def 100644
--- a/crates/agent2/src/tests/test_tools.rs
+++ b/crates/agent2/src/tests/test_tools.rs
@@ -24,7 +24,11 @@ impl AgentTool for EchoTool {
         acp::ToolKind::Other
     }
 
-    fn initial_title(&self, _input: Result<Self::Input, serde_json::Value>) -> SharedString {
+    fn initial_title(
+        &self,
+        _input: Result<Self::Input, serde_json::Value>,
+        _cx: &mut App,
+    ) -> SharedString {
         "Echo".into()
     }
 
@@ -55,7 +59,11 @@ impl AgentTool for DelayTool {
         "delay"
     }
 
-    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+    fn initial_title(
+        &self,
+        input: Result<Self::Input, serde_json::Value>,
+        _cx: &mut App,
+    ) -> SharedString {
         if let Ok(input) = input {
             format!("Delay {}ms", input.ms).into()
         } else {
@@ -100,7 +108,11 @@ impl AgentTool for ToolRequiringPermission {
         acp::ToolKind::Other
     }
 
-    fn initial_title(&self, _input: Result<Self::Input, serde_json::Value>) -> SharedString {
+    fn initial_title(
+        &self,
+        _input: Result<Self::Input, serde_json::Value>,
+        _cx: &mut App,
+    ) -> SharedString {
         "This tool requires permission".into()
     }
 
@@ -135,7 +147,11 @@ impl AgentTool for InfiniteTool {
         acp::ToolKind::Other
     }
 
-    fn initial_title(&self, _input: Result<Self::Input, serde_json::Value>) -> SharedString {
+    fn initial_title(
+        &self,
+        _input: Result<Self::Input, serde_json::Value>,
+        _cx: &mut App,
+    ) -> SharedString {
         "Infinite Tool".into()
     }
 
@@ -186,7 +202,11 @@ impl AgentTool for WordListTool {
         acp::ToolKind::Other
     }
 
-    fn initial_title(&self, _input: Result<Self::Input, serde_json::Value>) -> SharedString {
+    fn initial_title(
+        &self,
+        _input: Result<Self::Input, serde_json::Value>,
+        _cx: &mut App,
+    ) -> SharedString {
         "List of random words".into()
     }
 
diff --git a/crates/agent2/src/thread.rs b/crates/agent2/src/thread.rs
index 6421e4982e9fef67af3c61f54f3374d59172f807..20c4cd07533b7cf9bd1dd00e666bbb66552db9d7 100644
--- a/crates/agent2/src/thread.rs
+++ b/crates/agent2/src/thread.rs
@@ -741,7 +741,7 @@ impl Thread {
             return;
         };
 
-        let title = tool.initial_title(tool_use.input.clone());
+        let title = tool.initial_title(tool_use.input.clone(), cx);
         let kind = tool.kind();
         stream.send_tool_call(&tool_use.id, title, kind, tool_use.input.clone());
 
@@ -1062,7 +1062,11 @@ impl Thread {
             self.action_log.clone(),
         ));
         self.add_tool(DiagnosticsTool::new(self.project.clone()));
-        self.add_tool(EditFileTool::new(cx.weak_entity(), language_registry));
+        self.add_tool(EditFileTool::new(
+            self.project.clone(),
+            cx.weak_entity(),
+            language_registry,
+        ));
         self.add_tool(FetchTool::new(self.project.read(cx).client().http_client()));
         self.add_tool(FindPathTool::new(self.project.clone()));
         self.add_tool(GrepTool::new(self.project.clone()));
@@ -1514,7 +1518,7 @@ impl Thread {
         let mut title = SharedString::from(&tool_use.name);
         let mut kind = acp::ToolKind::Other;
         if let Some(tool) = tool.as_ref() {
-            title = tool.initial_title(tool_use.input.clone());
+            title = tool.initial_title(tool_use.input.clone(), cx);
             kind = tool.kind();
         }
 
@@ -2148,7 +2152,11 @@ where
     fn kind() -> acp::ToolKind;
 
     /// The initial tool title to display. Can be updated during the tool run.
-    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString;
+    fn initial_title(
+        &self,
+        input: Result<Self::Input, serde_json::Value>,
+        cx: &mut App,
+    ) -> SharedString;
 
     /// Returns the JSON schema that describes the tool's input.
     fn input_schema(&self, format: LanguageModelToolSchemaFormat) -> Schema {
@@ -2196,7 +2204,7 @@ pub trait AnyAgentTool {
     fn name(&self) -> SharedString;
     fn description(&self) -> SharedString;
     fn kind(&self) -> acp::ToolKind;
-    fn initial_title(&self, input: serde_json::Value) -> SharedString;
+    fn initial_title(&self, input: serde_json::Value, _cx: &mut App) -> SharedString;
     fn input_schema(&self, format: LanguageModelToolSchemaFormat) -> Result<serde_json::Value>;
     fn supported_provider(&self, _provider: &LanguageModelProviderId) -> bool {
         true
@@ -2232,9 +2240,9 @@ where
         T::kind()
     }
 
-    fn initial_title(&self, input: serde_json::Value) -> SharedString {
+    fn initial_title(&self, input: serde_json::Value, _cx: &mut App) -> SharedString {
         let parsed_input = serde_json::from_value(input.clone()).map_err(|_| input);
-        self.0.initial_title(parsed_input)
+        self.0.initial_title(parsed_input, _cx)
     }
 
     fn input_schema(&self, format: LanguageModelToolSchemaFormat) -> Result<serde_json::Value> {
diff --git a/crates/agent2/src/tools/context_server_registry.rs b/crates/agent2/src/tools/context_server_registry.rs
index e13f47fb2399d7408c5047ff6491ce2d2e76d948..46fa0298044de017464dc1a2e5bd21bf57c1bfcf 100644
--- a/crates/agent2/src/tools/context_server_registry.rs
+++ b/crates/agent2/src/tools/context_server_registry.rs
@@ -145,7 +145,7 @@ impl AnyAgentTool for ContextServerTool {
         ToolKind::Other
     }
 
-    fn initial_title(&self, _input: serde_json::Value) -> SharedString {
+    fn initial_title(&self, _input: serde_json::Value, _cx: &mut App) -> SharedString {
         format!("Run MCP tool `{}`", self.tool.name).into()
     }
 
@@ -176,7 +176,7 @@ impl AnyAgentTool for ContextServerTool {
             return Task::ready(Err(anyhow!("Context server not found")));
         };
         let tool_name = self.tool.name.clone();
-        let authorize = event_stream.authorize(self.initial_title(input.clone()), cx);
+        let authorize = event_stream.authorize(self.initial_title(input.clone(), cx), cx);
 
         cx.spawn(async move |_cx| {
             authorize.await?;
diff --git a/crates/agent2/src/tools/copy_path_tool.rs b/crates/agent2/src/tools/copy_path_tool.rs
index 819a6ff20931a42f892d60df91f665aac3694401..8fcd80391f828c7503701a86e9e1b400115763d6 100644
--- a/crates/agent2/src/tools/copy_path_tool.rs
+++ b/crates/agent2/src/tools/copy_path_tool.rs
@@ -58,7 +58,11 @@ impl AgentTool for CopyPathTool {
         ToolKind::Move
     }
 
-    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> ui::SharedString {
+    fn initial_title(
+        &self,
+        input: Result<Self::Input, serde_json::Value>,
+        _cx: &mut App,
+    ) -> ui::SharedString {
         if let Ok(input) = input {
             let src = MarkdownInlineCode(&input.source_path);
             let dest = MarkdownInlineCode(&input.destination_path);
diff --git a/crates/agent2/src/tools/create_directory_tool.rs b/crates/agent2/src/tools/create_directory_tool.rs
index 652363d5fa2320819076f5465b701eec04d9cd9f..30bd6418db35182358ed6139a9078e40a29dfac5 100644
--- a/crates/agent2/src/tools/create_directory_tool.rs
+++ b/crates/agent2/src/tools/create_directory_tool.rs
@@ -49,7 +49,11 @@ impl AgentTool for CreateDirectoryTool {
         ToolKind::Read
     }
 
-    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+    fn initial_title(
+        &self,
+        input: Result<Self::Input, serde_json::Value>,
+        _cx: &mut App,
+    ) -> SharedString {
         if let Ok(input) = input {
             format!("Create directory {}", MarkdownInlineCode(&input.path)).into()
         } else {
diff --git a/crates/agent2/src/tools/delete_path_tool.rs b/crates/agent2/src/tools/delete_path_tool.rs
index 0f9641127f1ffdbfec72d6d404acf5186a2bf12f..01a77f5d811127b3df470ec73fbc91ff7c26fd52 100644
--- a/crates/agent2/src/tools/delete_path_tool.rs
+++ b/crates/agent2/src/tools/delete_path_tool.rs
@@ -52,7 +52,11 @@ impl AgentTool for DeletePathTool {
         ToolKind::Delete
     }
 
-    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+    fn initial_title(
+        &self,
+        input: Result<Self::Input, serde_json::Value>,
+        _cx: &mut App,
+    ) -> SharedString {
         if let Ok(input) = input {
             format!("Delete “`{}`”", input.path).into()
         } else {
diff --git a/crates/agent2/src/tools/diagnostics_tool.rs b/crates/agent2/src/tools/diagnostics_tool.rs
index 558bb918ced71a1777dde919a59de9eab4129d45..a38e317d43cb16d8ee652f1a5f7aabd8b1ce4c8f 100644
--- a/crates/agent2/src/tools/diagnostics_tool.rs
+++ b/crates/agent2/src/tools/diagnostics_tool.rs
@@ -71,7 +71,11 @@ impl AgentTool for DiagnosticsTool {
         acp::ToolKind::Read
     }
 
-    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+    fn initial_title(
+        &self,
+        input: Result<Self::Input, serde_json::Value>,
+        _cx: &mut App,
+    ) -> SharedString {
         if let Some(path) = input.ok().and_then(|input| match input.path {
             Some(path) if !path.is_empty() => Some(path),
             _ => None,
diff --git a/crates/agent2/src/tools/edit_file_tool.rs b/crates/agent2/src/tools/edit_file_tool.rs
index ae37dc1f1340f9aa25789930b8f792ed8c3c8356..9237961bce513d740989c7e3076395ed68473859 100644
--- a/crates/agent2/src/tools/edit_file_tool.rs
+++ b/crates/agent2/src/tools/edit_file_tool.rs
@@ -120,11 +120,17 @@ impl From<EditFileToolOutput> for LanguageModelToolResultContent {
 pub struct EditFileTool {
     thread: WeakEntity<Thread>,
     language_registry: Arc<LanguageRegistry>,
+    project: Entity<Project>,
 }
 
 impl EditFileTool {
-    pub fn new(thread: WeakEntity<Thread>, language_registry: Arc<LanguageRegistry>) -> Self {
+    pub fn new(
+        project: Entity<Project>,
+        thread: WeakEntity<Thread>,
+        language_registry: Arc<LanguageRegistry>,
+    ) -> Self {
         Self {
+            project,
             thread,
             language_registry,
         }
@@ -195,22 +201,50 @@ impl AgentTool for EditFileTool {
         acp::ToolKind::Edit
     }
 
-    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+    fn initial_title(
+        &self,
+        input: Result<Self::Input, serde_json::Value>,
+        cx: &mut App,
+    ) -> SharedString {
         match input {
-            Ok(input) => input.display_description.into(),
+            Ok(input) => self
+                .project
+                .read(cx)
+                .find_project_path(&input.path, cx)
+                .and_then(|project_path| {
+                    self.project
+                        .read(cx)
+                        .short_full_path_for_project_path(&project_path, cx)
+                })
+                .unwrap_or(Path::new(&input.path).into())
+                .to_string_lossy()
+                .to_string()
+                .into(),
             Err(raw_input) => {
                 if let Some(input) =
                     serde_json::from_value::<EditFileToolPartialInput>(raw_input).ok()
                 {
+                    let path = input.path.trim();
+                    if !path.is_empty() {
+                        return self
+                            .project
+                            .read(cx)
+                            .find_project_path(&input.path, cx)
+                            .and_then(|project_path| {
+                                self.project
+                                    .read(cx)
+                                    .short_full_path_for_project_path(&project_path, cx)
+                            })
+                            .unwrap_or(Path::new(&input.path).into())
+                            .to_string_lossy()
+                            .to_string()
+                            .into();
+                    }
+
                     let description = input.display_description.trim();
                     if !description.is_empty() {
                         return description.to_string().into();
                     }
-
-                    let path = input.path.trim().to_string();
-                    if !path.is_empty() {
-                        return path.into();
-                    }
                 }
 
                 DEFAULT_UI_TEXT.into()
@@ -545,7 +579,7 @@ mod tests {
         let model = Arc::new(FakeLanguageModel::default());
         let thread = cx.new(|cx| {
             Thread::new(
-                project,
+                project.clone(),
                 cx.new(|_cx| ProjectContext::default()),
                 context_server_registry,
                 Templates::new(),
@@ -560,11 +594,12 @@ mod tests {
                     path: "root/nonexistent_file.txt".into(),
                     mode: EditFileMode::Edit,
                 };
-                Arc::new(EditFileTool::new(thread.downgrade(), language_registry)).run(
-                    input,
-                    ToolCallEventStream::test().0,
-                    cx,
-                )
+                Arc::new(EditFileTool::new(
+                    project,
+                    thread.downgrade(),
+                    language_registry,
+                ))
+                .run(input, ToolCallEventStream::test().0, cx)
             })
             .await;
         assert_eq!(
@@ -743,7 +778,7 @@ mod tests {
         let model = Arc::new(FakeLanguageModel::default());
         let thread = cx.new(|cx| {
             Thread::new(
-                project,
+                project.clone(),
                 cx.new(|_cx| ProjectContext::default()),
                 context_server_registry,
                 Templates::new(),
@@ -775,6 +810,7 @@ mod tests {
                     mode: EditFileMode::Overwrite,
                 };
                 Arc::new(EditFileTool::new(
+                    project.clone(),
                     thread.downgrade(),
                     language_registry.clone(),
                 ))
@@ -833,11 +869,12 @@ mod tests {
                     path: "root/src/main.rs".into(),
                     mode: EditFileMode::Overwrite,
                 };
-                Arc::new(EditFileTool::new(thread.downgrade(), language_registry)).run(
-                    input,
-                    ToolCallEventStream::test().0,
-                    cx,
-                )
+                Arc::new(EditFileTool::new(
+                    project.clone(),
+                    thread.downgrade(),
+                    language_registry,
+                ))
+                .run(input, ToolCallEventStream::test().0, cx)
             });
 
             // Stream the unformatted content
@@ -885,7 +922,7 @@ mod tests {
         let model = Arc::new(FakeLanguageModel::default());
         let thread = cx.new(|cx| {
             Thread::new(
-                project,
+                project.clone(),
                 cx.new(|_cx| ProjectContext::default()),
                 context_server_registry,
                 Templates::new(),
@@ -918,6 +955,7 @@ mod tests {
                     mode: EditFileMode::Overwrite,
                 };
                 Arc::new(EditFileTool::new(
+                    project.clone(),
                     thread.downgrade(),
                     language_registry.clone(),
                 ))
@@ -969,11 +1007,12 @@ mod tests {
                     path: "root/src/main.rs".into(),
                     mode: EditFileMode::Overwrite,
                 };
-                Arc::new(EditFileTool::new(thread.downgrade(), language_registry)).run(
-                    input,
-                    ToolCallEventStream::test().0,
-                    cx,
-                )
+                Arc::new(EditFileTool::new(
+                    project.clone(),
+                    thread.downgrade(),
+                    language_registry,
+                ))
+                .run(input, ToolCallEventStream::test().0, cx)
             });
 
             // Stream the content with trailing whitespace
@@ -1012,7 +1051,7 @@ mod tests {
         let model = Arc::new(FakeLanguageModel::default());
         let thread = cx.new(|cx| {
             Thread::new(
-                project,
+                project.clone(),
                 cx.new(|_cx| ProjectContext::default()),
                 context_server_registry,
                 Templates::new(),
@@ -1020,7 +1059,11 @@ mod tests {
                 cx,
             )
         });
-        let tool = Arc::new(EditFileTool::new(thread.downgrade(), language_registry));
+        let tool = Arc::new(EditFileTool::new(
+            project.clone(),
+            thread.downgrade(),
+            language_registry,
+        ));
         fs.insert_tree("/root", json!({})).await;
 
         // Test 1: Path with .zed component should require confirmation
@@ -1148,7 +1191,7 @@ mod tests {
         let model = Arc::new(FakeLanguageModel::default());
         let thread = cx.new(|cx| {
             Thread::new(
-                project,
+                project.clone(),
                 cx.new(|_cx| ProjectContext::default()),
                 context_server_registry,
                 Templates::new(),
@@ -1156,7 +1199,11 @@ mod tests {
                 cx,
             )
         });
-        let tool = Arc::new(EditFileTool::new(thread.downgrade(), language_registry));
+        let tool = Arc::new(EditFileTool::new(
+            project.clone(),
+            thread.downgrade(),
+            language_registry,
+        ));
 
         // Test global config paths - these should require confirmation if they exist and are outside the project
         let test_cases = vec![
@@ -1264,7 +1311,11 @@ mod tests {
                 cx,
             )
         });
-        let tool = Arc::new(EditFileTool::new(thread.downgrade(), language_registry));
+        let tool = Arc::new(EditFileTool::new(
+            project.clone(),
+            thread.downgrade(),
+            language_registry,
+        ));
 
         // Test files in different worktrees
         let test_cases = vec![
@@ -1344,7 +1395,11 @@ mod tests {
                 cx,
             )
         });
-        let tool = Arc::new(EditFileTool::new(thread.downgrade(), language_registry));
+        let tool = Arc::new(EditFileTool::new(
+            project.clone(),
+            thread.downgrade(),
+            language_registry,
+        ));
 
         // Test edge cases
         let test_cases = vec![
@@ -1427,7 +1482,11 @@ mod tests {
                 cx,
             )
         });
-        let tool = Arc::new(EditFileTool::new(thread.downgrade(), language_registry));
+        let tool = Arc::new(EditFileTool::new(
+            project.clone(),
+            thread.downgrade(),
+            language_registry,
+        ));
 
         // Test different EditFileMode values
         let modes = vec![
@@ -1507,48 +1566,67 @@ mod tests {
                 cx,
             )
         });
-        let tool = Arc::new(EditFileTool::new(thread.downgrade(), language_registry));
+        let tool = Arc::new(EditFileTool::new(
+            project,
+            thread.downgrade(),
+            language_registry,
+        ));
 
-        assert_eq!(
-            tool.initial_title(Err(json!({
-                "path": "src/main.rs",
-                "display_description": "",
-                "old_string": "old code",
-                "new_string": "new code"
-            }))),
-            "src/main.rs"
-        );
-        assert_eq!(
-            tool.initial_title(Err(json!({
-                "path": "",
-                "display_description": "Fix error handling",
-                "old_string": "old code",
-                "new_string": "new code"
-            }))),
-            "Fix error handling"
-        );
-        assert_eq!(
-            tool.initial_title(Err(json!({
-                "path": "src/main.rs",
-                "display_description": "Fix error handling",
-                "old_string": "old code",
-                "new_string": "new code"
-            }))),
-            "Fix error handling"
-        );
-        assert_eq!(
-            tool.initial_title(Err(json!({
-                "path": "",
-                "display_description": "",
-                "old_string": "old code",
-                "new_string": "new code"
-            }))),
-            DEFAULT_UI_TEXT
-        );
-        assert_eq!(
-            tool.initial_title(Err(serde_json::Value::Null)),
-            DEFAULT_UI_TEXT
-        );
+        cx.update(|cx| {
+            // ...
+            assert_eq!(
+                tool.initial_title(
+                    Err(json!({
+                        "path": "src/main.rs",
+                        "display_description": "",
+                        "old_string": "old code",
+                        "new_string": "new code"
+                    })),
+                    cx
+                ),
+                "src/main.rs"
+            );
+            assert_eq!(
+                tool.initial_title(
+                    Err(json!({
+                        "path": "",
+                        "display_description": "Fix error handling",
+                        "old_string": "old code",
+                        "new_string": "new code"
+                    })),
+                    cx
+                ),
+                "Fix error handling"
+            );
+            assert_eq!(
+                tool.initial_title(
+                    Err(json!({
+                        "path": "src/main.rs",
+                        "display_description": "Fix error handling",
+                        "old_string": "old code",
+                        "new_string": "new code"
+                    })),
+                    cx
+                ),
+                "src/main.rs"
+            );
+            assert_eq!(
+                tool.initial_title(
+                    Err(json!({
+                        "path": "",
+                        "display_description": "",
+                        "old_string": "old code",
+                        "new_string": "new code"
+                    })),
+                    cx
+                ),
+                DEFAULT_UI_TEXT
+            );
+            assert_eq!(
+                tool.initial_title(Err(serde_json::Value::Null), cx),
+                DEFAULT_UI_TEXT
+            );
+        });
     }
 
     #[gpui::test]
@@ -1575,7 +1653,11 @@ mod tests {
 
         // Ensure the diff is finalized after the edit completes.
         {
-            let tool = Arc::new(EditFileTool::new(thread.downgrade(), languages.clone()));
+            let tool = Arc::new(EditFileTool::new(
+                project.clone(),
+                thread.downgrade(),
+                languages.clone(),
+            ));
             let (stream_tx, mut stream_rx) = ToolCallEventStream::test();
             let edit = cx.update(|cx| {
                 tool.run(
@@ -1600,7 +1682,11 @@ mod tests {
         // Ensure the diff is finalized if an error occurs while editing.
         {
             model.forbid_requests();
-            let tool = Arc::new(EditFileTool::new(thread.downgrade(), languages.clone()));
+            let tool = Arc::new(EditFileTool::new(
+                project.clone(),
+                thread.downgrade(),
+                languages.clone(),
+            ));
             let (stream_tx, mut stream_rx) = ToolCallEventStream::test();
             let edit = cx.update(|cx| {
                 tool.run(
@@ -1623,7 +1709,11 @@ mod tests {
 
         // Ensure the diff is finalized if the tool call gets dropped.
         {
-            let tool = Arc::new(EditFileTool::new(thread.downgrade(), languages.clone()));
+            let tool = Arc::new(EditFileTool::new(
+                project.clone(),
+                thread.downgrade(),
+                languages.clone(),
+            ));
             let (stream_tx, mut stream_rx) = ToolCallEventStream::test();
             let edit = cx.update(|cx| {
                 tool.run(
diff --git a/crates/agent2/src/tools/fetch_tool.rs b/crates/agent2/src/tools/fetch_tool.rs
index dd97271a799d11daf09e95147c18ab07d55e1caf..60654ac863acdc559aeaad90f1c73727f33d1b59 100644
--- a/crates/agent2/src/tools/fetch_tool.rs
+++ b/crates/agent2/src/tools/fetch_tool.rs
@@ -126,7 +126,11 @@ impl AgentTool for FetchTool {
         acp::ToolKind::Fetch
     }
 
-    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+    fn initial_title(
+        &self,
+        input: Result<Self::Input, serde_json::Value>,
+        _cx: &mut App,
+    ) -> SharedString {
         match input {
             Ok(input) => format!("Fetch {}", MarkdownEscaped(&input.url)).into(),
             Err(_) => "Fetch URL".into(),
diff --git a/crates/agent2/src/tools/find_path_tool.rs b/crates/agent2/src/tools/find_path_tool.rs
index 384bd56e776d8814e668d6fe3104a394c63b639d..735ec67cffa31969e4eef741d6a23de05f3e15dc 100644
--- a/crates/agent2/src/tools/find_path_tool.rs
+++ b/crates/agent2/src/tools/find_path_tool.rs
@@ -93,7 +93,11 @@ impl AgentTool for FindPathTool {
         acp::ToolKind::Search
     }
 
-    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+    fn initial_title(
+        &self,
+        input: Result<Self::Input, serde_json::Value>,
+        _cx: &mut App,
+    ) -> SharedString {
         let mut title = "Find paths".to_string();
         if let Ok(input) = input {
             title.push_str(&format!(" matching “`{}`”", input.glob));
diff --git a/crates/agent2/src/tools/grep_tool.rs b/crates/agent2/src/tools/grep_tool.rs
index b24e773903e76fe8e11287d054dd758670669ca2..e76a16bcc7f57b035fb1e2b09243d22230b52085 100644
--- a/crates/agent2/src/tools/grep_tool.rs
+++ b/crates/agent2/src/tools/grep_tool.rs
@@ -75,7 +75,11 @@ impl AgentTool for GrepTool {
         acp::ToolKind::Search
     }
 
-    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+    fn initial_title(
+        &self,
+        input: Result<Self::Input, serde_json::Value>,
+        _cx: &mut App,
+    ) -> SharedString {
         match input {
             Ok(input) => {
                 let page = input.page();
diff --git a/crates/agent2/src/tools/list_directory_tool.rs b/crates/agent2/src/tools/list_directory_tool.rs
index e6fa8d743122ec117f4307a1c4a37ddd79bd574a..0fbe23fe205e6a9bd5a77e737460c17b997f9175 100644
--- a/crates/agent2/src/tools/list_directory_tool.rs
+++ b/crates/agent2/src/tools/list_directory_tool.rs
@@ -59,7 +59,11 @@ impl AgentTool for ListDirectoryTool {
         ToolKind::Read
     }
 
-    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+    fn initial_title(
+        &self,
+        input: Result<Self::Input, serde_json::Value>,
+        _cx: &mut App,
+    ) -> SharedString {
         if let Ok(input) = input {
             let path = MarkdownInlineCode(&input.path);
             format!("List the {path} directory's contents").into()
diff --git a/crates/agent2/src/tools/move_path_tool.rs b/crates/agent2/src/tools/move_path_tool.rs
index d9fb60651b8cbb9d38713d660cf2e43070ef1f53..91880c1243e0aa48569ab8e6981ddd45b41ab411 100644
--- a/crates/agent2/src/tools/move_path_tool.rs
+++ b/crates/agent2/src/tools/move_path_tool.rs
@@ -60,7 +60,11 @@ impl AgentTool for MovePathTool {
         ToolKind::Move
     }
 
-    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+    fn initial_title(
+        &self,
+        input: Result<Self::Input, serde_json::Value>,
+        _cx: &mut App,
+    ) -> SharedString {
         if let Ok(input) = input {
             let src = MarkdownInlineCode(&input.source_path);
             let dest = MarkdownInlineCode(&input.destination_path);
diff --git a/crates/agent2/src/tools/now_tool.rs b/crates/agent2/src/tools/now_tool.rs
index 49068be0dd91993ae7cc4d866617d399d754d529..3387c0a617017991f8b2590868864287f399ec28 100644
--- a/crates/agent2/src/tools/now_tool.rs
+++ b/crates/agent2/src/tools/now_tool.rs
@@ -41,7 +41,11 @@ impl AgentTool for NowTool {
         acp::ToolKind::Other
     }
 
-    fn initial_title(&self, _input: Result<Self::Input, serde_json::Value>) -> SharedString {
+    fn initial_title(
+        &self,
+        _input: Result<Self::Input, serde_json::Value>,
+        _cx: &mut App,
+    ) -> SharedString {
         "Get current time".into()
     }
 
diff --git a/crates/agent2/src/tools/open_tool.rs b/crates/agent2/src/tools/open_tool.rs
index df7b04c787df27cb8f4f1fccac0017b8d71994a8..595a9f380b752635f97ef5d1819a1140c1db8be0 100644
--- a/crates/agent2/src/tools/open_tool.rs
+++ b/crates/agent2/src/tools/open_tool.rs
@@ -45,7 +45,11 @@ impl AgentTool for OpenTool {
         ToolKind::Execute
     }
 
-    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+    fn initial_title(
+        &self,
+        input: Result<Self::Input, serde_json::Value>,
+        _cx: &mut App,
+    ) -> SharedString {
         if let Ok(input) = input {
             format!("Open `{}`", MarkdownEscaped(&input.path_or_url)).into()
         } else {
@@ -61,7 +65,7 @@ impl AgentTool for OpenTool {
     ) -> Task<Result<Self::Output>> {
         // If path_or_url turns out to be a path in the project, make it absolute.
         let abs_path = to_absolute_path(&input.path_or_url, self.project.clone(), cx);
-        let authorize = event_stream.authorize(self.initial_title(Ok(input.clone())), cx);
+        let authorize = event_stream.authorize(self.initial_title(Ok(input.clone()), cx), cx);
         cx.background_spawn(async move {
             authorize.await?;
 
diff --git a/crates/agent2/src/tools/read_file_tool.rs b/crates/agent2/src/tools/read_file_tool.rs
index e771c26eca6e453a8f3d4150079b31a839227a4d..99f145901c664624d66d7487cce579f55cff908a 100644
--- a/crates/agent2/src/tools/read_file_tool.rs
+++ b/crates/agent2/src/tools/read_file_tool.rs
@@ -10,7 +10,7 @@ use project::{AgentLocation, ImageItem, Project, WorktreeSettings, image_store};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::Settings;
-use std::{path::Path, sync::Arc};
+use std::sync::Arc;
 use util::markdown::MarkdownCodeBlock;
 
 use crate::{AgentTool, ToolCallEventStream};
@@ -68,13 +68,31 @@ impl AgentTool for ReadFileTool {
         acp::ToolKind::Read
     }
 
-    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
-        input
-            .ok()
-            .as_ref()
-            .and_then(|input| Path::new(&input.path).file_name())
-            .map(|file_name| file_name.to_string_lossy().to_string().into())
-            .unwrap_or_default()
+    fn initial_title(
+        &self,
+        input: Result<Self::Input, serde_json::Value>,
+        cx: &mut App,
+    ) -> SharedString {
+        if let Ok(input) = input
+            && let Some(project_path) = self.project.read(cx).find_project_path(&input.path, cx)
+            && let Some(path) = self
+                .project
+                .read(cx)
+                .short_full_path_for_project_path(&project_path, cx)
+        {
+            match (input.start_line, input.end_line) {
+                (Some(start), Some(end)) => {
+                    format!("Read file `{}` (lines {}-{})", path.display(), start, end,)
+                }
+                (Some(start), None) => {
+                    format!("Read file `{}` (from line {})", path.display(), start)
+                }
+                _ => format!("Read file `{}`", path.display()),
+            }
+            .into()
+        } else {
+            "Read file".into()
+        }
     }
 
     fn run(
@@ -86,6 +104,12 @@ impl AgentTool for ReadFileTool {
         let Some(project_path) = self.project.read(cx).find_project_path(&input.path, cx) else {
             return Task::ready(Err(anyhow!("Path {} not found in project", &input.path)));
         };
+        let Some(abs_path) = self.project.read(cx).absolute_path(&project_path, cx) else {
+            return Task::ready(Err(anyhow!(
+                "Failed to convert {} to absolute path",
+                &input.path
+            )));
+        };
 
         // Error out if this path is either excluded or private in global settings
         let global_settings = WorktreeSettings::get_global(cx);
@@ -121,6 +145,14 @@ impl AgentTool for ReadFileTool {
 
         let file_path = input.path.clone();
 
+        event_stream.update_fields(ToolCallUpdateFields {
+            locations: Some(vec![acp::ToolCallLocation {
+                path: abs_path,
+                line: input.start_line.map(|line| line.saturating_sub(1)),
+            }]),
+            ..Default::default()
+        });
+
         if image_store::is_image_file(&self.project, &project_path, cx) {
             return cx.spawn(async move |cx| {
                 let image_entity: Entity<ImageItem> = cx
@@ -229,34 +261,25 @@ impl AgentTool for ReadFileTool {
             };
 
             project.update(cx, |project, cx| {
-                if let Some(abs_path) = project.absolute_path(&project_path, cx) {
-                    project.set_agent_location(
-                        Some(AgentLocation {
-                            buffer: buffer.downgrade(),
-                            position: anchor.unwrap_or(text::Anchor::MIN),
-                        }),
-                        cx,
-                    );
+                project.set_agent_location(
+                    Some(AgentLocation {
+                        buffer: buffer.downgrade(),
+                        position: anchor.unwrap_or(text::Anchor::MIN),
+                    }),
+                    cx,
+                );
+                if let Ok(LanguageModelToolResultContent::Text(text)) = &result {
+                    let markdown = MarkdownCodeBlock {
+                        tag: &input.path,
+                        text,
+                    }
+                    .to_string();
                     event_stream.update_fields(ToolCallUpdateFields {
-                        locations: Some(vec![acp::ToolCallLocation {
-                            path: abs_path,
-                            line: input.start_line.map(|line| line.saturating_sub(1)),
+                        content: Some(vec![acp::ToolCallContent::Content {
+                            content: markdown.into(),
                         }]),
                         ..Default::default()
-                    });
-                    if let Ok(LanguageModelToolResultContent::Text(text)) = &result {
-                        let markdown = MarkdownCodeBlock {
-                            tag: &input.path,
-                            text,
-                        }
-                        .to_string();
-                        event_stream.update_fields(ToolCallUpdateFields {
-                            content: Some(vec![acp::ToolCallContent::Content {
-                                content: markdown.into(),
-                            }]),
-                            ..Default::default()
-                        })
-                    }
+                    })
                 }
             })?;
 
diff --git a/crates/agent2/src/tools/terminal_tool.rs b/crates/agent2/src/tools/terminal_tool.rs
index 9ed585b1386e4958fe8d458a0376a70e0ef70862..7acfc2455093eac0f3d15e840abce47f38a6c8b0 100644
--- a/crates/agent2/src/tools/terminal_tool.rs
+++ b/crates/agent2/src/tools/terminal_tool.rs
@@ -60,7 +60,11 @@ impl AgentTool for TerminalTool {
         acp::ToolKind::Execute
     }
 
-    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
+    fn initial_title(
+        &self,
+        input: Result<Self::Input, serde_json::Value>,
+        _cx: &mut App,
+    ) -> SharedString {
         if let Ok(input) = input {
             let mut lines = input.command.lines();
             let first_line = lines.next().unwrap_or_default();
@@ -93,7 +97,7 @@ impl AgentTool for TerminalTool {
             Err(err) => return Task::ready(Err(err)),
         };
 
-        let authorize = event_stream.authorize(self.initial_title(Ok(input.clone())), cx);
+        let authorize = event_stream.authorize(self.initial_title(Ok(input.clone()), cx), cx);
         cx.spawn(async move |cx| {
             authorize.await?;
 
diff --git a/crates/agent2/src/tools/thinking_tool.rs b/crates/agent2/src/tools/thinking_tool.rs
index 61fb9eb0d6ea95f1aa299f1d226c7f2c5b750767..0a68f7545f81ce3202c110b1435d33b57adf409c 100644
--- a/crates/agent2/src/tools/thinking_tool.rs
+++ b/crates/agent2/src/tools/thinking_tool.rs
@@ -29,7 +29,11 @@ impl AgentTool for ThinkingTool {
         acp::ToolKind::Think
     }
 
-    fn initial_title(&self, _input: Result<Self::Input, serde_json::Value>) -> SharedString {
+    fn initial_title(
+        &self,
+        _input: Result<Self::Input, serde_json::Value>,
+        _cx: &mut App,
+    ) -> SharedString {
         "Thinking".into()
     }
 
diff --git a/crates/agent2/src/tools/web_search_tool.rs b/crates/agent2/src/tools/web_search_tool.rs
index d7a34bec29e10476b31051d71d6d2f74b640ad5d..ce26bccddeeb998abf6d39cbe2acfe91cecc6d1b 100644
--- a/crates/agent2/src/tools/web_search_tool.rs
+++ b/crates/agent2/src/tools/web_search_tool.rs
@@ -48,7 +48,11 @@ impl AgentTool for WebSearchTool {
         acp::ToolKind::Fetch
     }
 
-    fn initial_title(&self, _input: Result<Self::Input, serde_json::Value>) -> SharedString {
+    fn initial_title(
+        &self,
+        _input: Result<Self::Input, serde_json::Value>,
+        _cx: &mut App,
+    ) -> SharedString {
         "Searching the Web".into()
     }
 
diff --git a/crates/agent_servers/Cargo.toml b/crates/agent_servers/Cargo.toml
index 222feb9aaa31a6ace1e13ba8943f416942e8918c..bb3fe6ff9078535b500e28f4beeab957929546a5 100644
--- a/crates/agent_servers/Cargo.toml
+++ b/crates/agent_servers/Cargo.toml
@@ -23,7 +23,7 @@ action_log.workspace = true
 agent-client-protocol.workspace = true
 agent_settings.workspace = true
 anyhow.workspace = true
-client = { workspace = true, optional = true }
+client.workspace = true
 collections.workspace = true
 env_logger = { workspace = true, optional = true }
 fs.workspace = true
@@ -35,22 +35,18 @@ language.workspace = true
 language_model.workspace = true
 language_models.workspace = true
 log.workspace = true
-node_runtime.workspace = true
-paths.workspace = true
 project.workspace = true
 reqwest_client = { workspace = true, optional = true }
-schemars.workspace = true
-semver.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 settings.workspace = true
 smol.workspace = true
+task.workspace = true
 tempfile.workspace = true
 thiserror.workspace = true
 ui.workspace = true
 util.workspace = true
 watch.workspace = true
-which.workspace = true
 workspace-hack.workspace = true
 
 [target.'cfg(unix)'.dependencies]
diff --git a/crates/agent_servers/src/acp.rs b/crates/agent_servers/src/acp.rs
index 7991c1e3ccedafe8891ef80c57c4939bb19d2fb1..191bae066ce255ca0e88da215c7513703f7ace0b 100644
--- a/crates/agent_servers/src/acp.rs
+++ b/crates/agent_servers/src/acp.rs
@@ -1,4 +1,3 @@
-use crate::AgentServerCommand;
 use acp_thread::AgentConnection;
 use acp_tools::AcpConnectionRegistry;
 use action_log::ActionLog;
@@ -8,8 +7,10 @@ use collections::HashMap;
 use futures::AsyncBufReadExt as _;
 use futures::io::BufReader;
 use project::Project;
+use project::agent_server_store::AgentServerCommand;
 use serde::Deserialize;
 
+use std::path::PathBuf;
 use std::{any::Any, cell::RefCell};
 use std::{path::Path, rc::Rc};
 use thiserror::Error;
@@ -29,6 +30,7 @@ pub struct AcpConnection {
     sessions: Rc<RefCell<HashMap<acp::SessionId, AcpSession>>>,
     auth_methods: Vec<acp::AuthMethod>,
     agent_capabilities: acp::AgentCapabilities,
+    root_dir: PathBuf,
     _io_task: Task<Result<()>>,
     _wait_task: Task<Result<()>>,
     _stderr_task: Task<Result<()>>,
@@ -43,9 +45,10 @@ pub async fn connect(
     server_name: SharedString,
     command: AgentServerCommand,
     root_dir: &Path,
+    is_remote: bool,
     cx: &mut AsyncApp,
 ) -> Result<Rc<dyn AgentConnection>> {
-    let conn = AcpConnection::stdio(server_name, command.clone(), root_dir, cx).await?;
+    let conn = AcpConnection::stdio(server_name, command.clone(), root_dir, is_remote, cx).await?;
     Ok(Rc::new(conn) as _)
 }
 
@@ -56,17 +59,21 @@ impl AcpConnection {
         server_name: SharedString,
         command: AgentServerCommand,
         root_dir: &Path,
+        is_remote: bool,
         cx: &mut AsyncApp,
     ) -> Result<Self> {
-        let mut child = util::command::new_smol_command(command.path)
+        let mut child = util::command::new_smol_command(command.path);
+        child
             .args(command.args.iter().map(|arg| arg.as_str()))
             .envs(command.env.iter().flatten())
-            .current_dir(root_dir)
             .stdin(std::process::Stdio::piped())
             .stdout(std::process::Stdio::piped())
             .stderr(std::process::Stdio::piped())
-            .kill_on_drop(true)
-            .spawn()?;
+            .kill_on_drop(true);
+        if !is_remote {
+            child.current_dir(root_dir);
+        }
+        let mut child = child.spawn()?;
 
         let stdout = child.stdout.take().context("Failed to take stdout")?;
         let stdin = child.stdin.take().context("Failed to take stdin")?;
@@ -145,6 +152,7 @@ impl AcpConnection {
 
         Ok(Self {
             auth_methods: response.auth_methods,
+            root_dir: root_dir.to_owned(),
             connection,
             server_name,
             sessions,
@@ -158,6 +166,10 @@ impl AcpConnection {
     pub fn prompt_capabilities(&self) -> &acp::PromptCapabilities {
         &self.agent_capabilities.prompt_capabilities
     }
+
+    pub fn root_dir(&self) -> &Path {
+        &self.root_dir
+    }
 }
 
 impl AgentConnection for AcpConnection {
@@ -171,29 +183,36 @@ impl AgentConnection for AcpConnection {
         let sessions = self.sessions.clone();
         let cwd = cwd.to_path_buf();
         let context_server_store = project.read(cx).context_server_store().read(cx);
-        let mcp_servers = context_server_store
-            .configured_server_ids()
-            .iter()
-            .filter_map(|id| {
-                let configuration = context_server_store.configuration_for_server(id)?;
-                let command = configuration.command();
-                Some(acp::McpServer {
-                    name: id.0.to_string(),
-                    command: command.path.clone(),
-                    args: command.args.clone(),
-                    env: if let Some(env) = command.env.as_ref() {
-                        env.iter()
-                            .map(|(name, value)| acp::EnvVariable {
-                                name: name.clone(),
-                                value: value.clone(),
-                            })
-                            .collect()
-                    } else {
-                        vec![]
-                    },
+        let mcp_servers = if project.read(cx).is_local() {
+            context_server_store
+                .configured_server_ids()
+                .iter()
+                .filter_map(|id| {
+                    let configuration = context_server_store.configuration_for_server(id)?;
+                    let command = configuration.command();
+                    Some(acp::McpServer {
+                        name: id.0.to_string(),
+                        command: command.path.clone(),
+                        args: command.args.clone(),
+                        env: if let Some(env) = command.env.as_ref() {
+                            env.iter()
+                                .map(|(name, value)| acp::EnvVariable {
+                                    name: name.clone(),
+                                    value: value.clone(),
+                                })
+                                .collect()
+                        } else {
+                            vec![]
+                        },
+                    })
                 })
-            })
-            .collect();
+                .collect()
+        } else {
+            // In SSH projects, the external agent is running on the remote
+            // machine, and currently we only run MCP servers on the local
+            // machine. So don't pass any MCP servers to the agent in that case.
+            Vec::new()
+        };
 
         cx.spawn(async move |cx| {
             let response = conn
diff --git a/crates/agent_servers/src/agent_servers.rs b/crates/agent_servers/src/agent_servers.rs
index e214dabfc763c2a46f1f4665c3d1f881d5ce406e..7f11d8ce93e9b34d5bb03e1c6306b57bad450efc 100644
--- a/crates/agent_servers/src/agent_servers.rs
+++ b/crates/agent_servers/src/agent_servers.rs
@@ -2,47 +2,25 @@ mod acp;
 mod claude;
 mod custom;
 mod gemini;
-mod settings;
 
 #[cfg(any(test, feature = "test-support"))]
 pub mod e2e_tests;
 
-use anyhow::Context as _;
 pub use claude::*;
 pub use custom::*;
-use fs::Fs;
-use fs::RemoveOptions;
-use fs::RenameOptions;
-use futures::StreamExt as _;
 pub use gemini::*;
-use gpui::AppContext;
-use node_runtime::NodeRuntime;
-pub use settings::*;
+use project::agent_server_store::AgentServerStore;
 
 use acp_thread::AgentConnection;
-use acp_thread::LoadError;
 use anyhow::Result;
-use anyhow::anyhow;
-use collections::HashMap;
-use gpui::{App, AsyncApp, Entity, SharedString, Task};
+use gpui::{App, Entity, SharedString, Task};
 use project::Project;
-use schemars::JsonSchema;
-use semver::Version;
-use serde::{Deserialize, Serialize};
-use std::str::FromStr as _;
-use std::{
-    any::Any,
-    path::{Path, PathBuf},
-    rc::Rc,
-    sync::Arc,
-};
-use util::ResultExt as _;
+use std::{any::Any, path::Path, rc::Rc};
 
-pub fn init(cx: &mut App) {
-    settings::init(cx);
-}
+pub use acp::AcpConnection;
 
 pub struct AgentServerDelegate {
+    store: Entity<AgentServerStore>,
     project: Entity<Project>,
     status_tx: Option<watch::Sender<SharedString>>,
     new_version_available: Option<watch::Sender<Option<String>>>,
@@ -50,11 +28,13 @@ pub struct AgentServerDelegate {
 
 impl AgentServerDelegate {
     pub fn new(
+        store: Entity<AgentServerStore>,
         project: Entity<Project>,
         status_tx: Option<watch::Sender<SharedString>>,
         new_version_tx: Option<watch::Sender<Option<String>>>,
     ) -> Self {
         Self {
+            store,
             project,
             status_tx,
             new_version_available: new_version_tx,
@@ -64,188 +44,6 @@ impl AgentServerDelegate {
     pub fn project(&self) -> &Entity<Project> {
         &self.project
     }
-
-    fn get_or_npm_install_builtin_agent(
-        self,
-        binary_name: SharedString,
-        package_name: SharedString,
-        entrypoint_path: PathBuf,
-        ignore_system_version: bool,
-        minimum_version: Option<Version>,
-        cx: &mut App,
-    ) -> Task<Result<AgentServerCommand>> {
-        let project = self.project;
-        let fs = project.read(cx).fs().clone();
-        let Some(node_runtime) = project.read(cx).node_runtime().cloned() else {
-            return Task::ready(Err(anyhow!(
-                "External agents are not yet available in remote projects."
-            )));
-        };
-        let status_tx = self.status_tx;
-        let new_version_available = self.new_version_available;
-
-        cx.spawn(async move |cx| {
-            if !ignore_system_version {
-                if let Some(bin) = find_bin_in_path(binary_name.clone(), &project, cx).await {
-                    return Ok(AgentServerCommand {
-                        path: bin,
-                        args: Vec::new(),
-                        env: Default::default(),
-                    });
-                }
-            }
-
-            cx.spawn(async move |cx| {
-                let node_path = node_runtime.binary_path().await?;
-                let dir = paths::data_dir()
-                    .join("external_agents")
-                    .join(binary_name.as_str());
-                fs.create_dir(&dir).await?;
-
-                let mut stream = fs.read_dir(&dir).await?;
-                let mut versions = Vec::new();
-                let mut to_delete = Vec::new();
-                while let Some(entry) = stream.next().await {
-                    let Ok(entry) = entry else { continue };
-                    let Some(file_name) = entry.file_name() else {
-                        continue;
-                    };
-
-                    if let Some(name) = file_name.to_str()
-                        && let Some(version) = semver::Version::from_str(name).ok()
-                        && fs
-                            .is_file(&dir.join(file_name).join(&entrypoint_path))
-                            .await
-                    {
-                        versions.push((version, file_name.to_owned()));
-                    } else {
-                        to_delete.push(file_name.to_owned())
-                    }
-                }
-
-                versions.sort();
-                let newest_version = if let Some((version, file_name)) = versions.last().cloned()
-                    && minimum_version.is_none_or(|minimum_version| version >= minimum_version)
-                {
-                    versions.pop();
-                    Some(file_name)
-                } else {
-                    None
-                };
-                log::debug!("existing version of {package_name}: {newest_version:?}");
-                to_delete.extend(versions.into_iter().map(|(_, file_name)| file_name));
-
-                cx.background_spawn({
-                    let fs = fs.clone();
-                    let dir = dir.clone();
-                    async move {
-                        for file_name in to_delete {
-                            fs.remove_dir(
-                                &dir.join(file_name),
-                                RemoveOptions {
-                                    recursive: true,
-                                    ignore_if_not_exists: false,
-                                },
-                            )
-                            .await
-                            .ok();
-                        }
-                    }
-                })
-                .detach();
-
-                let version = if let Some(file_name) = newest_version {
-                    cx.background_spawn({
-                        let file_name = file_name.clone();
-                        let dir = dir.clone();
-                        let fs = fs.clone();
-                        async move {
-                            let latest_version =
-                                node_runtime.npm_package_latest_version(&package_name).await;
-                            if let Ok(latest_version) = latest_version
-                                && &latest_version != &file_name.to_string_lossy()
-                            {
-                                Self::download_latest_version(
-                                    fs,
-                                    dir.clone(),
-                                    node_runtime,
-                                    package_name,
-                                )
-                                .await
-                                .log_err();
-                                if let Some(mut new_version_available) = new_version_available {
-                                    new_version_available.send(Some(latest_version)).ok();
-                                }
-                            }
-                        }
-                    })
-                    .detach();
-                    file_name
-                } else {
-                    if let Some(mut status_tx) = status_tx {
-                        status_tx.send("Installing…".into()).ok();
-                    }
-                    let dir = dir.clone();
-                    cx.background_spawn(Self::download_latest_version(
-                        fs.clone(),
-                        dir.clone(),
-                        node_runtime,
-                        package_name,
-                    ))
-                    .await?
-                    .into()
-                };
-
-                let agent_server_path = dir.join(version).join(entrypoint_path);
-                let agent_server_path_exists = fs.is_file(&agent_server_path).await;
-                anyhow::ensure!(
-                    agent_server_path_exists,
-                    "Missing entrypoint path {} after installation",
-                    agent_server_path.to_string_lossy()
-                );
-
-                anyhow::Ok(AgentServerCommand {
-                    path: node_path,
-                    args: vec![agent_server_path.to_string_lossy().to_string()],
-                    env: Default::default(),
-                })
-            })
-            .await
-            .map_err(|e| LoadError::FailedToInstall(e.to_string().into()).into())
-        })
-    }
-
-    async fn download_latest_version(
-        fs: Arc<dyn Fs>,
-        dir: PathBuf,
-        node_runtime: NodeRuntime,
-        package_name: SharedString,
-    ) -> Result<String> {
-        log::debug!("downloading latest version of {package_name}");
-
-        let tmp_dir = tempfile::tempdir_in(&dir)?;
-
-        node_runtime
-            .npm_install_packages(tmp_dir.path(), &[(&package_name, "latest")])
-            .await?;
-
-        let version = node_runtime
-            .npm_package_installed_version(tmp_dir.path(), &package_name)
-            .await?
-            .context("expected package to be installed")?;
-
-        fs.rename(
-            &tmp_dir.keep(),
-            &dir.join(&version),
-            RenameOptions {
-                ignore_if_exists: true,
-                overwrite: false,
-            },
-        )
-        .await?;
-
-        anyhow::Ok(version)
-    }
 }
 
 pub trait AgentServer: Send {
@@ -255,10 +53,10 @@ pub trait AgentServer: Send {
 
     fn connect(
         &self,
-        root_dir: &Path,
+        root_dir: Option<&Path>,
         delegate: AgentServerDelegate,
         cx: &mut App,
-    ) -> Task<Result<Rc<dyn AgentConnection>>>;
+    ) -> Task<Result<(Rc<dyn AgentConnection>, Option<task::SpawnInTerminal>)>>;
 
     fn into_any(self: Rc<Self>) -> Rc<dyn Any>;
 }
@@ -268,120 +66,3 @@ impl dyn AgentServer {
         self.into_any().downcast().ok()
     }
 }
-
-impl std::fmt::Debug for AgentServerCommand {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let filtered_env = self.env.as_ref().map(|env| {
-            env.iter()
-                .map(|(k, v)| {
-                    (
-                        k,
-                        if util::redact::should_redact(k) {
-                            "[REDACTED]"
-                        } else {
-                            v
-                        },
-                    )
-                })
-                .collect::<Vec<_>>()
-        });
-
-        f.debug_struct("AgentServerCommand")
-            .field("path", &self.path)
-            .field("args", &self.args)
-            .field("env", &filtered_env)
-            .finish()
-    }
-}
-
-#[derive(Deserialize, Serialize, Clone, PartialEq, Eq, JsonSchema)]
-pub struct AgentServerCommand {
-    #[serde(rename = "command")]
-    pub path: PathBuf,
-    #[serde(default)]
-    pub args: Vec<String>,
-    pub env: Option<HashMap<String, String>>,
-}
-
-impl AgentServerCommand {
-    pub async fn resolve(
-        path_bin_name: &'static str,
-        extra_args: &[&'static str],
-        fallback_path: Option<&Path>,
-        settings: Option<BuiltinAgentServerSettings>,
-        project: &Entity<Project>,
-        cx: &mut AsyncApp,
-    ) -> Option<Self> {
-        if let Some(settings) = settings
-            && let Some(command) = settings.custom_command()
-        {
-            Some(command)
-        } else {
-            match find_bin_in_path(path_bin_name.into(), project, cx).await {
-                Some(path) => Some(Self {
-                    path,
-                    args: extra_args.iter().map(|arg| arg.to_string()).collect(),
-                    env: None,
-                }),
-                None => fallback_path.and_then(|path| {
-                    if path.exists() {
-                        Some(Self {
-                            path: path.to_path_buf(),
-                            args: extra_args.iter().map(|arg| arg.to_string()).collect(),
-                            env: None,
-                        })
-                    } else {
-                        None
-                    }
-                }),
-            }
-        }
-    }
-}
-
-async fn find_bin_in_path(
-    bin_name: SharedString,
-    project: &Entity<Project>,
-    cx: &mut AsyncApp,
-) -> Option<PathBuf> {
-    let (env_task, root_dir) = project
-        .update(cx, |project, cx| {
-            let worktree = project.visible_worktrees(cx).next();
-            match worktree {
-                Some(worktree) => {
-                    let env_task = project.environment().update(cx, |env, cx| {
-                        env.get_worktree_environment(worktree.clone(), cx)
-                    });
-
-                    let path = worktree.read(cx).abs_path();
-                    (env_task, path)
-                }
-                None => {
-                    let path: Arc<Path> = paths::home_dir().as_path().into();
-                    let env_task = project.environment().update(cx, |env, cx| {
-                        env.get_directory_environment(path.clone(), cx)
-                    });
-                    (env_task, path)
-                }
-            }
-        })
-        .log_err()?;
-
-    cx.background_executor()
-        .spawn(async move {
-            let which_result = if cfg!(windows) {
-                which::which(bin_name.as_str())
-            } else {
-                let env = env_task.await.unwrap_or_default();
-                let shell_path = env.get("PATH").cloned();
-                which::which_in(bin_name.as_str(), shell_path.as_ref(), root_dir.as_ref())
-            };
-
-            if let Err(which::Error::CannotFindBinaryPath) = which_result {
-                return None;
-            }
-
-            which_result.log_err()
-        })
-        .await
-}
diff --git a/crates/agent_servers/src/claude.rs b/crates/agent_servers/src/claude.rs
index 28b7c844c3797d799add40163fd034dd4fb335a7..1291894cb83931b9f622e760bf7fe7cc8f675157 100644
--- a/crates/agent_servers/src/claude.rs
+++ b/crates/agent_servers/src/claude.rs
@@ -1,61 +1,22 @@
-use language_models::provider::anthropic::AnthropicLanguageModelProvider;
-use settings::SettingsStore;
 use std::path::Path;
 use std::rc::Rc;
 use std::{any::Any, path::PathBuf};
 
-use anyhow::Result;
-use gpui::{App, AppContext as _, SharedString, Task};
+use anyhow::{Context as _, Result};
+use gpui::{App, SharedString, Task};
+use project::agent_server_store::CLAUDE_CODE_NAME;
 
-use crate::{AgentServer, AgentServerDelegate, AllAgentServersSettings};
+use crate::{AgentServer, AgentServerDelegate};
 use acp_thread::AgentConnection;
 
 #[derive(Clone)]
 pub struct ClaudeCode;
 
-pub struct ClaudeCodeLoginCommand {
+pub struct AgentServerLoginCommand {
     pub path: PathBuf,
     pub arguments: Vec<String>,
 }
 
-impl ClaudeCode {
-    const BINARY_NAME: &'static str = "claude-code-acp";
-    const PACKAGE_NAME: &'static str = "@zed-industries/claude-code-acp";
-
-    pub fn login_command(
-        delegate: AgentServerDelegate,
-        cx: &mut App,
-    ) -> Task<Result<ClaudeCodeLoginCommand>> {
-        let settings = cx.read_global(|settings: &SettingsStore, _| {
-            settings.get::<AllAgentServersSettings>(None).claude.clone()
-        });
-
-        cx.spawn(async move |cx| {
-            let mut command = if let Some(settings) = settings {
-                settings.command
-            } else {
-                cx.update(|cx| {
-                    delegate.get_or_npm_install_builtin_agent(
-                        Self::BINARY_NAME.into(),
-                        Self::PACKAGE_NAME.into(),
-                        "node_modules/@anthropic-ai/claude-code/cli.js".into(),
-                        true,
-                        Some("0.2.5".parse().unwrap()),
-                        cx,
-                    )
-                })?
-                .await?
-            };
-            command.args.push("/login".into());
-
-            Ok(ClaudeCodeLoginCommand {
-                path: command.path,
-                arguments: command.args,
-            })
-        })
-    }
-}
-
 impl AgentServer for ClaudeCode {
     fn telemetry_id(&self) -> &'static str {
         "claude-code"
@@ -71,16 +32,14 @@ impl AgentServer for ClaudeCode {
 
     fn connect(
         &self,
-        root_dir: &Path,
+        root_dir: Option<&Path>,
         delegate: AgentServerDelegate,
         cx: &mut App,
-    ) -> Task<Result<Rc<dyn AgentConnection>>> {
-        let root_dir = root_dir.to_path_buf();
-        let fs = delegate.project().read(cx).fs().clone();
-        let server_name = self.name();
-        let settings = cx.read_global(|settings: &SettingsStore, _| {
-            settings.get::<AllAgentServersSettings>(None).claude.clone()
-        });
+    ) -> Task<Result<(Rc<dyn AgentConnection>, Option<task::SpawnInTerminal>)>> {
+        let name = self.name();
+        let root_dir = root_dir.map(|root_dir| root_dir.to_string_lossy().to_string());
+        let is_remote = delegate.project.read(cx).is_via_remote_server();
+        let store = delegate.store.downgrade();
 
         // Get the project environment variables for the root directory
         let project_env = delegate.project().update(cx, |project, cx| {
@@ -92,54 +51,23 @@ impl AgentServer for ClaudeCode {
         });
 
         cx.spawn(async move |cx| {
-            let mut command = if let Some(settings) = settings {
-                settings.command
-            } else {
-                cx.update(|cx| {
-                    delegate.get_or_npm_install_builtin_agent(
-                        Self::BINARY_NAME.into(),
-                        Self::PACKAGE_NAME.into(),
-                        format!("node_modules/{}/dist/index.js", Self::PACKAGE_NAME).into(),
-                        true,
-                        None,
-                        cx,
-                    )
-                })?
-                .await?
-            };
-
-            // Merge project environment variables (from .env files, etc.)
-            if let Some(project_env) = project_env
-                && let Some(env) = dbg!(project_env.await)
-            {
-                if let Some(command_env) = &mut command.env {
-                    command_env.extend(
-                        env.iter()
-                            .map(|(key, val)| dbg!((key.clone(), val.clone()))),
-                    );
-                }
-            }
-
-            // Add the API key if available (project-specific env may override this)
-            if let Some(api_key) = cx
-                .update(AnthropicLanguageModelProvider::api_key)?
-                .await
-                .ok()
-            {
-                command
-                    .env
-                    .get_or_insert_default()
-                    .insert("ANTHROPIC_API_KEY".to_owned(), api_key.key);
-            }
-
-            let root_dir_exists = fs.is_dir(&root_dir).await;
-            anyhow::ensure!(
-                root_dir_exists,
-                "Session root {} does not exist or is not a directory",
-                root_dir.to_string_lossy()
-            );
-
-            crate::acp::connect(server_name, command.clone(), &root_dir, cx).await
+            let (command, root_dir, login) = store
+                .update(cx, |store, cx| {
+                    let agent = store
+                        .get_external_agent(&CLAUDE_CODE_NAME.into())
+                        .context("Claude Code is not registered")?;
+                    anyhow::Ok(agent.get_command(
+                        root_dir.as_deref(),
+                        Default::default(),
+                        delegate.status_tx,
+                        delegate.new_version_available,
+                        &mut cx.to_async(),
+                    ))
+                })??
+                .await?;
+            let connection =
+                crate::acp::connect(name, command, root_dir.as_ref(), is_remote, cx).await?;
+            Ok((connection, login))
         })
     }
 
diff --git a/crates/agent_servers/src/custom.rs b/crates/agent_servers/src/custom.rs
index 5a6d251d2987934e5622a818a3a29720a039327b..0fb595ff02cda53ee5ffe4e778417e35d86a8805 100644
--- a/crates/agent_servers/src/custom.rs
+++ b/crates/agent_servers/src/custom.rs
@@ -1,19 +1,19 @@
-use crate::{AgentServerCommand, AgentServerDelegate};
+use crate::AgentServerDelegate;
 use acp_thread::AgentConnection;
-use anyhow::Result;
+use anyhow::{Context as _, Result};
 use gpui::{App, SharedString, Task};
+use project::agent_server_store::ExternalAgentServerName;
 use std::{path::Path, rc::Rc};
 use ui::IconName;
 
 /// A generic agent server implementation for custom user-defined agents
 pub struct CustomAgentServer {
     name: SharedString,
-    command: AgentServerCommand,
 }
 
 impl CustomAgentServer {
-    pub fn new(name: SharedString, command: AgentServerCommand) -> Self {
-        Self { name, command }
+    pub fn new(name: SharedString) -> Self {
+        Self { name }
     }
 }
 
@@ -32,32 +32,35 @@ impl crate::AgentServer for CustomAgentServer {
 
     fn connect(
         &self,
-        root_dir: &Path,
+        root_dir: Option<&Path>,
         delegate: AgentServerDelegate,
         cx: &mut App,
-    ) -> Task<Result<Rc<dyn AgentConnection>>> {
-        let server_name = self.name();
-        let mut command = self.command.clone();
-        let root_dir = root_dir.to_path_buf();
-
-        // Get the project environment variables for the root directory
-        let project_env = delegate.project().update(cx, |project, cx| {
-            project.directory_environment(root_dir.as_path().into(), cx)
-        });
+    ) -> Task<Result<(Rc<dyn AgentConnection>, Option<task::SpawnInTerminal>)>> {
+        let name = self.name();
+        let root_dir = root_dir.map(|root_dir| root_dir.to_string_lossy().to_string());
+        let is_remote = delegate.project.read(cx).is_via_remote_server();
+        let store = delegate.store.downgrade();
 
         cx.spawn(async move |cx| {
-            // Start with project environment variables (from shell, .env files, etc.)
-            let mut env = project_env.await.unwrap_or_default();
-
-            // Merge with any existing command env (command env takes precedence)
-            if let Some(command_env) = &command.env {
-                env.extend(command_env.clone());
-            }
-
-            // Set the merged environment back on the command
-            command.env = Some(env);
-
-            crate::acp::connect(server_name, command, &root_dir, cx).await
+            let (command, root_dir, login) = store
+                .update(cx, |store, cx| {
+                    let agent = store
+                        .get_external_agent(&ExternalAgentServerName(name.clone()))
+                        .with_context(|| {
+                            format!("Custom agent server `{}` is not registered", name)
+                        })?;
+                    anyhow::Ok(agent.get_command(
+                        root_dir.as_deref(),
+                        Default::default(),
+                        delegate.status_tx,
+                        delegate.new_version_available,
+                        &mut cx.to_async(),
+                    ))
+                })??
+                .await?;
+            let connection =
+                crate::acp::connect(name, command, root_dir.as_ref(), is_remote, cx).await?;
+            Ok((connection, login))
         })
     }
 
diff --git a/crates/agent_servers/src/e2e_tests.rs b/crates/agent_servers/src/e2e_tests.rs
index f801ef246807f93c4bbdc26a1ff3bd478cc476d0..eda55a596a2fbfd20024ea9f15157d6d9dd7c2b3 100644
--- a/crates/agent_servers/src/e2e_tests.rs
+++ b/crates/agent_servers/src/e2e_tests.rs
@@ -1,12 +1,12 @@
 use crate::{AgentServer, AgentServerDelegate};
-#[cfg(test)]
-use crate::{AgentServerCommand, CustomAgentServerSettings};
 use acp_thread::{AcpThread, AgentThreadEntry, ToolCall, ToolCallStatus};
 use agent_client_protocol as acp;
 use futures::{FutureExt, StreamExt, channel::mpsc, select};
 use gpui::{AppContext, Entity, TestAppContext};
 use indoc::indoc;
-use project::{FakeFs, Project};
+#[cfg(test)]
+use project::agent_server_store::{AgentServerCommand, CustomAgentServerSettings};
+use project::{FakeFs, Project, agent_server_store::AllAgentServersSettings};
 use std::{
     path::{Path, PathBuf},
     sync::Arc,
@@ -449,7 +449,6 @@ pub use common_e2e_tests;
 // Helpers
 
 pub async fn init_test(cx: &mut TestAppContext) -> Arc<FakeFs> {
-    #[cfg(test)]
     use settings::Settings;
 
     env_logger::try_init().ok();
@@ -468,11 +467,11 @@ pub async fn init_test(cx: &mut TestAppContext) -> Arc<FakeFs> {
         language_model::init(client.clone(), cx);
         language_models::init(user_store, client, cx);
         agent_settings::init(cx);
-        crate::settings::init(cx);
+        AllAgentServersSettings::register(cx);
 
         #[cfg(test)]
-        crate::AllAgentServersSettings::override_global(
-            crate::AllAgentServersSettings {
+        AllAgentServersSettings::override_global(
+            AllAgentServersSettings {
                 claude: Some(CustomAgentServerSettings {
                     command: AgentServerCommand {
                         path: "claude-code-acp".into(),
@@ -498,10 +497,11 @@ pub async fn new_test_thread(
     current_dir: impl AsRef<Path>,
     cx: &mut TestAppContext,
 ) -> Entity<AcpThread> {
-    let delegate = AgentServerDelegate::new(project.clone(), None, None);
+    let store = project.read_with(cx, |project, _| project.agent_server_store().clone());
+    let delegate = AgentServerDelegate::new(store, project.clone(), None, None);
 
-    let connection = cx
-        .update(|cx| server.connect(current_dir.as_ref(), delegate, cx))
+    let (connection, _) = cx
+        .update(|cx| server.connect(Some(current_dir.as_ref()), delegate, cx))
         .await
         .unwrap();
 
diff --git a/crates/agent_servers/src/gemini.rs b/crates/agent_servers/src/gemini.rs
index b1be16df1b2e185d28134b15a2aa5e1e2215bcc9..cf553273db87d7400b56956741540bd061a9c231 100644
--- a/crates/agent_servers/src/gemini.rs
+++ b/crates/agent_servers/src/gemini.rs
@@ -1,21 +1,19 @@
 use std::rc::Rc;
 use std::{any::Any, path::Path};
 
-use crate::acp::AcpConnection;
 use crate::{AgentServer, AgentServerDelegate};
-use acp_thread::{AgentConnection, LoadError};
-use anyhow::Result;
-use gpui::{App, AppContext as _, SharedString, Task};
+use acp_thread::AgentConnection;
+use anyhow::{Context as _, Result};
+use client::ProxySettings;
+use collections::HashMap;
+use gpui::{App, AppContext, SharedString, Task};
 use language_models::provider::google::GoogleLanguageModelProvider;
+use project::agent_server_store::GEMINI_NAME;
 use settings::SettingsStore;
 
-use crate::AllAgentServersSettings;
-
 #[derive(Clone)]
 pub struct Gemini;
 
-const ACP_ARG: &str = "--experimental-acp";
-
 impl AgentServer for Gemini {
     fn telemetry_id(&self) -> &'static str {
         "gemini-cli"
@@ -31,134 +29,49 @@ impl AgentServer for Gemini {
 
     fn connect(
         &self,
-        root_dir: &Path,
+        root_dir: Option<&Path>,
         delegate: AgentServerDelegate,
         cx: &mut App,
-    ) -> Task<Result<Rc<dyn AgentConnection>>> {
-        let root_dir = root_dir.to_path_buf();
-        let fs = delegate.project().read(cx).fs().clone();
-        let server_name = self.name();
-        let settings = cx.read_global(|settings: &SettingsStore, _| {
-            settings.get::<AllAgentServersSettings>(None).gemini.clone()
-        });
-
-        // Get the project environment variables for the root directory
-        let project_env = delegate.project().update(cx, |project, cx| {
-            project.directory_environment(root_dir.as_path().into(), cx)
+    ) -> Task<Result<(Rc<dyn AgentConnection>, Option<task::SpawnInTerminal>)>> {
+        let name = self.name();
+        let root_dir = root_dir.map(|root_dir| root_dir.to_string_lossy().to_string());
+        let is_remote = delegate.project.read(cx).is_via_remote_server();
+        let store = delegate.store.downgrade();
+        let proxy_url = cx.read_global(|settings: &SettingsStore, _| {
+            settings.get::<ProxySettings>(None).proxy.clone()
         });
 
         cx.spawn(async move |cx| {
-            let ignore_system_version = settings
-                .as_ref()
-                .and_then(|settings| settings.ignore_system_version)
-                .unwrap_or(true);
-            let mut command = if let Some(settings) = settings
-                && let Some(command) = settings.custom_command()
-            {
-                command
-            } else {
-                cx.update(|cx| {
-                    delegate.get_or_npm_install_builtin_agent(
-                        Self::BINARY_NAME.into(),
-                        Self::PACKAGE_NAME.into(),
-                        format!("node_modules/{}/dist/index.js", Self::PACKAGE_NAME).into(),
-                        ignore_system_version,
-                        Some(Self::MINIMUM_VERSION.parse().unwrap()),
-                        cx,
-                    )
-                })?
-                .await?
-            };
-            if !command.args.contains(&ACP_ARG.into()) {
-                command.args.push(ACP_ARG.into());
-            }
-
-            // Start with project environment variables (from shell, .env files, etc.)
-            let mut env = project_env.await.unwrap_or_default();
-
-            // Add the API key if available (this takes precedence over project env)
+            let mut extra_env = HashMap::default();
             if let Some(api_key) = cx.update(GoogleLanguageModelProvider::api_key)?.await.ok() {
-                env.insert("GEMINI_API_KEY".to_owned(), api_key.key);
+                extra_env.insert("GEMINI_API_KEY".into(), api_key.key);
             }
-
-            // Merge with any existing command env (command env takes precedence)
-            if let Some(command_env) = &command.env {
-                env.extend(command_env.clone());
+            let (mut command, root_dir, login) = store
+                .update(cx, |store, cx| {
+                    let agent = store
+                        .get_external_agent(&GEMINI_NAME.into())
+                        .context("Gemini CLI is not registered")?;
+                    anyhow::Ok(agent.get_command(
+                        root_dir.as_deref(),
+                        extra_env,
+                        delegate.status_tx,
+                        delegate.new_version_available,
+                        &mut cx.to_async(),
+                    ))
+                })??
+                .await?;
+
+            // Add proxy flag if proxy settings are configured in Zed and not in the args
+            if let Some(proxy_url_value) = &proxy_url
+                && !command.args.iter().any(|arg| arg.contains("--proxy"))
+            {
+                command.args.push("--proxy".into());
+                command.args.push(proxy_url_value.clone());
             }
 
-            // Set the merged environment back on the command
-            command.env = Some(env);
-
-            let root_dir_exists = fs.is_dir(&root_dir).await;
-            anyhow::ensure!(
-                root_dir_exists,
-                "Session root {} does not exist or is not a directory",
-                root_dir.to_string_lossy()
-            );
-
-            let result = crate::acp::connect(server_name, command.clone(), &root_dir, cx).await;
-            match &result {
-                Ok(connection) => {
-                    if let Some(connection) = connection.clone().downcast::<AcpConnection>()
-                        && !connection.prompt_capabilities().image
-                    {
-                        let version_output = util::command::new_smol_command(&command.path)
-                            .args(command.args.iter())
-                            .arg("--version")
-                            .kill_on_drop(true)
-                            .output()
-                            .await;
-                        let current_version =
-                            String::from_utf8(version_output?.stdout)?.trim().to_owned();
-
-                        log::error!("connected to gemini, but missing prompt_capabilities.image (version is {current_version})");
-                        return Err(LoadError::Unsupported {
-                            current_version: current_version.into(),
-                            command: (command.path.to_string_lossy().to_string() + " " + &command.args.join(" ")).into(),
-                            minimum_version: Self::MINIMUM_VERSION.into(),
-                        }
-                        .into());
-                    }
-                }
-                Err(e) => {
-                    let version_fut = util::command::new_smol_command(&command.path)
-                        .args(command.args.iter())
-                        .arg("--version")
-                        .kill_on_drop(true)
-                        .output();
-
-                    let help_fut = util::command::new_smol_command(&command.path)
-                        .args(command.args.iter())
-                        .arg("--help")
-                        .kill_on_drop(true)
-                        .output();
-
-                    let (version_output, help_output) =
-                        futures::future::join(version_fut, help_fut).await;
-                    let Some(version_output) = version_output.ok().and_then(|output| String::from_utf8(output.stdout).ok()) else {
-                        return result;
-                    };
-                    let Some((help_stdout, help_stderr)) = help_output.ok().and_then(|output| String::from_utf8(output.stdout).ok().zip(String::from_utf8(output.stderr).ok())) else  {
-                        return result;
-                    };
-
-                    let current_version = version_output.trim().to_string();
-                    let supported = help_stdout.contains(ACP_ARG) || current_version.parse::<semver::Version>().is_ok_and(|version| version >= Self::MINIMUM_VERSION.parse::<semver::Version>().unwrap());
-
-                    log::error!("failed to create ACP connection to gemini (version is {current_version}, supported: {supported}): {e}");
-                    log::debug!("gemini --help stdout: {help_stdout:?}");
-                    log::debug!("gemini --help stderr: {help_stderr:?}");
-                    if !supported {
-                        return Err(LoadError::Unsupported {
-                            current_version: current_version.into(),
-                            command: (command.path.to_string_lossy().to_string() + " " + &command.args.join(" ")).into(),
-                            minimum_version: Self::MINIMUM_VERSION.into(),
-                        }
-                        .into());
-                    }
-                }
-            }
-            result
+            let connection =
+                crate::acp::connect(name, command, root_dir.as_ref(), is_remote, cx).await?;
+            Ok((connection, login))
         })
     }
 
@@ -167,18 +80,11 @@ impl AgentServer for Gemini {
     }
 }
 
-impl Gemini {
-    const PACKAGE_NAME: &str = "@google/gemini-cli";
-
-    const MINIMUM_VERSION: &str = "0.2.1";
-
-    const BINARY_NAME: &str = "gemini";
-}
-
 #[cfg(test)]
 pub(crate) mod tests {
+    use project::agent_server_store::AgentServerCommand;
+
     use super::*;
-    use crate::AgentServerCommand;
     use std::path::Path;
 
     crate::common_e2e_tests!(async |_, _, _| Gemini, allow_option_id = "proceed_once");
diff --git a/crates/agent_servers/src/settings.rs b/crates/agent_servers/src/settings.rs
deleted file mode 100644
index 693d7d7b7014b3abbecfbe592bac67210b336872..0000000000000000000000000000000000000000
--- a/crates/agent_servers/src/settings.rs
+++ /dev/null
@@ -1,111 +0,0 @@
-use std::path::PathBuf;
-
-use crate::AgentServerCommand;
-use anyhow::Result;
-use collections::HashMap;
-use gpui::{App, SharedString};
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
-
-pub fn init(cx: &mut App) {
-    AllAgentServersSettings::register(cx);
-}
-
-#[derive(Default, Deserialize, Serialize, Clone, JsonSchema, Debug, SettingsUi)]
-pub struct AllAgentServersSettings {
-    pub gemini: Option<BuiltinAgentServerSettings>,
-    pub claude: Option<CustomAgentServerSettings>,
-
-    /// Custom agent servers configured by the user
-    #[serde(flatten)]
-    pub custom: HashMap<SharedString, CustomAgentServerSettings>,
-}
-
-#[derive(Default, Deserialize, Serialize, Clone, JsonSchema, Debug, PartialEq)]
-pub struct BuiltinAgentServerSettings {
-    /// Absolute path to a binary to be used when launching this agent.
-    ///
-    /// This can be used to run a specific binary without automatic downloads or searching `$PATH`.
-    #[serde(rename = "command")]
-    pub path: Option<PathBuf>,
-    /// If a binary is specified in `command`, it will be passed these arguments.
-    pub args: Option<Vec<String>>,
-    /// If a binary is specified in `command`, it will be passed these environment variables.
-    pub env: Option<HashMap<String, String>>,
-    /// Whether to skip searching `$PATH` for an agent server binary when
-    /// launching this agent.
-    ///
-    /// This has no effect if a `command` is specified. Otherwise, when this is
-    /// `false`, Zed will search `$PATH` for an agent server binary and, if one
-    /// is found, use it for threads with this agent. If no agent binary is
-    /// found on `$PATH`, Zed will automatically install and use its own binary.
-    /// When this is `true`, Zed will not search `$PATH`, and will always use
-    /// its own binary.
-    ///
-    /// Default: true
-    pub ignore_system_version: Option<bool>,
-}
-
-impl BuiltinAgentServerSettings {
-    pub(crate) fn custom_command(self) -> Option<AgentServerCommand> {
-        self.path.map(|path| AgentServerCommand {
-            path,
-            args: self.args.unwrap_or_default(),
-            env: self.env,
-        })
-    }
-}
-
-impl From<AgentServerCommand> for BuiltinAgentServerSettings {
-    fn from(value: AgentServerCommand) -> Self {
-        BuiltinAgentServerSettings {
-            path: Some(value.path),
-            args: Some(value.args),
-            env: value.env,
-            ..Default::default()
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize, Clone, JsonSchema, Debug, PartialEq)]
-pub struct CustomAgentServerSettings {
-    #[serde(flatten)]
-    pub command: AgentServerCommand,
-}
-
-impl settings::Settings for AllAgentServersSettings {
-    const KEY: Option<&'static str> = Some("agent_servers");
-
-    type FileContent = Self;
-
-    fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
-        let mut settings = AllAgentServersSettings::default();
-
-        for AllAgentServersSettings {
-            gemini,
-            claude,
-            custom,
-        } in sources.defaults_and_customizations()
-        {
-            if gemini.is_some() {
-                settings.gemini = gemini.clone();
-            }
-            if claude.is_some() {
-                settings.claude = claude.clone();
-            }
-
-            // Merge custom agents
-            for (name, config) in custom {
-                // Skip built-in agent names to avoid conflicts
-                if name != "gemini" && name != "claude" {
-                    settings.custom.insert(name.clone(), config.clone());
-                }
-            }
-        }
-
-        Ok(settings)
-    }
-
-    fn import_from_vscode(_vscode: &settings::VsCodeSettings, _current: &mut Self::FileContent) {}
-}
diff --git a/crates/agent_settings/src/agent_settings.rs b/crates/agent_settings/src/agent_settings.rs
index 8aebdcd288c8451d9bc391f1fc1598d6098d55af..8c4a190e1c3135b5bbfbc90544bb92db7a6bdd22 100644
--- a/crates/agent_settings/src/agent_settings.rs
+++ b/crates/agent_settings/src/agent_settings.rs
@@ -8,7 +8,7 @@ use gpui::{App, Pixels, SharedString};
 use language_model::LanguageModel;
 use schemars::{JsonSchema, json_schema};
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 use std::borrow::Cow;
 
 pub use crate::agent_profile::*;
@@ -223,7 +223,8 @@ impl AgentSettingsContent {
     }
 }
 
-#[derive(Clone, Serialize, Deserialize, JsonSchema, Debug, Default, SettingsUi)]
+#[derive(Clone, Serialize, Deserialize, JsonSchema, Debug, Default, SettingsUi, SettingsKey)]
+#[settings_key(key = "agent", fallback_key = "assistant")]
 pub struct AgentSettingsContent {
     /// Whether the Agent is enabled.
     ///
@@ -399,10 +400,6 @@ pub struct ContextServerPresetContent {
 }
 
 impl Settings for AgentSettings {
-    const KEY: Option<&'static str> = Some("agent");
-
-    const FALLBACK_KEY: Option<&'static str> = Some("assistant");
-
     const PRESERVED_KEYS: Option<&'static [&'static str]> = Some(&["version"]);
 
     type FileContent = AgentSettingsContent;
diff --git a/crates/agent_ui/src/acp/completion_provider.rs b/crates/agent_ui/src/acp/completion_provider.rs
index 44e81433ab5a9d904f329e238b24960e2d568750..f4bc6eaf7f0a2e6f2ec59dbda9e0d4cdcbfa668b 100644
--- a/crates/agent_ui/src/acp/completion_provider.rs
+++ b/crates/agent_ui/src/acp/completion_provider.rs
@@ -1025,43 +1025,31 @@ impl SlashCommandCompletion {
             return None;
         }
 
-        let last_command_start = line.rfind('/')?;
-        if last_command_start >= line.len() {
-            return Some(Self::default());
-        }
-        if last_command_start > 0
-            && line
-                .chars()
-                .nth(last_command_start - 1)
-                .is_some_and(|c| !c.is_whitespace())
+        let (prefix, last_command) = line.rsplit_once('/')?;
+        if prefix.chars().last().is_some_and(|c| !c.is_whitespace())
+            || last_command.starts_with(char::is_whitespace)
         {
             return None;
         }
 
-        let rest_of_line = &line[last_command_start + 1..];
-
-        let mut command = None;
         let mut argument = None;
-        let mut end = last_command_start + 1;
-
-        if let Some(command_text) = rest_of_line.split_whitespace().next() {
-            command = Some(command_text.to_string());
-            end += command_text.len();
-
-            // Find the start of arguments after the command
-            if let Some(args_start) =
-                rest_of_line[command_text.len()..].find(|c: char| !c.is_whitespace())
-            {
-                let args = &rest_of_line[command_text.len() + args_start..].trim_end();
-                if !args.is_empty() {
-                    argument = Some(args.to_string());
-                    end += args.len() + 1;
-                }
+        let mut command = None;
+        if let Some((command_text, args)) = last_command.split_once(char::is_whitespace) {
+            if !args.is_empty() {
+                argument = Some(args.trim_end().to_string());
             }
-        }
+            command = Some(command_text.to_string());
+        } else if !last_command.is_empty() {
+            command = Some(last_command.to_string());
+        };
 
         Some(Self {
-            source_range: last_command_start + offset_to_line..end + offset_to_line,
+            source_range: prefix.len() + offset_to_line
+                ..line
+                    .rfind(|c: char| !c.is_whitespace())
+                    .unwrap_or_else(|| line.len())
+                    + 1
+                    + offset_to_line,
             command,
             argument,
         })
@@ -1078,13 +1066,21 @@ struct MentionCompletion {
 impl MentionCompletion {
     fn try_parse(allow_non_file_mentions: bool, line: &str, offset_to_line: usize) -> Option<Self> {
         let last_mention_start = line.rfind('@')?;
-        if last_mention_start >= line.len() {
-            return Some(Self::default());
+
+        // No whitespace immediately after '@'
+        if line[last_mention_start + 1..]
+            .chars()
+            .next()
+            .is_some_and(|c| c.is_whitespace())
+        {
+            return None;
         }
+
+        //  Must be a word boundary before '@'
         if last_mention_start > 0
-            && line
+            && line[..last_mention_start]
                 .chars()
-                .nth(last_mention_start - 1)
+                .last()
                 .is_some_and(|c| !c.is_whitespace())
         {
             return None;
@@ -1097,7 +1093,9 @@ impl MentionCompletion {
 
         let mut parts = rest_of_line.split_whitespace();
         let mut end = last_mention_start + 1;
+
         if let Some(mode_text) = parts.next() {
+            // Safe since we check no leading whitespace above
             end += mode_text.len();
 
             if let Some(parsed_mode) = ContextPickerMode::try_from(mode_text).ok()
@@ -1180,6 +1178,15 @@ mod tests {
             })
         );
 
+        assert_eq!(
+            SlashCommandCompletion::try_parse("/拿不到命令 拿不到命令 ", 0),
+            Some(SlashCommandCompletion {
+                source_range: 0..30,
+                command: Some("拿不到命令".to_string()),
+                argument: Some("拿不到命令".to_string()),
+            })
+        );
+
         assert_eq!(SlashCommandCompletion::try_parse("Lorem Ipsum", 0), None);
 
         assert_eq!(SlashCommandCompletion::try_parse("Lorem /", 0), None);
@@ -1187,6 +1194,8 @@ mod tests {
         assert_eq!(SlashCommandCompletion::try_parse("Lorem /help", 0), None);
 
         assert_eq!(SlashCommandCompletion::try_parse("Lorem/", 0), None);
+
+        assert_eq!(SlashCommandCompletion::try_parse("/ ", 0), None);
     }
 
     #[test]
@@ -1279,5 +1288,23 @@ mod tests {
                 argument: Some("main".to_string()),
             })
         );
+
+        assert_eq!(
+            MentionCompletion::try_parse(true, "Lorem@symbol", 0),
+            None,
+            "Should not parse mention inside word"
+        );
+
+        assert_eq!(
+            MentionCompletion::try_parse(true, "Lorem @ file", 0),
+            None,
+            "Should not parse with a space after @"
+        );
+
+        assert_eq!(
+            MentionCompletion::try_parse(true, "@ file", 0),
+            None,
+            "Should not parse with a space after @ at the start of the line"
+        );
     }
 }
diff --git a/crates/agent_ui/src/acp/entry_view_state.rs b/crates/agent_ui/src/acp/entry_view_state.rs
index e60b923ca78c4613e9b8d8063a280f560d788d44..ec57ea7e6df3244b6ea1bcb99212d845fa68c457 100644
--- a/crates/agent_ui/src/acp/entry_view_state.rs
+++ b/crates/agent_ui/src/acp/entry_view_state.rs
@@ -207,7 +207,7 @@ impl EntryViewState {
         self.entries.drain(range);
     }
 
-    pub fn settings_changed(&mut self, cx: &mut App) {
+    pub fn agent_font_size_changed(&mut self, cx: &mut App) {
         for entry in self.entries.iter() {
             match entry {
                 Entry::UserMessage { .. } | Entry::AssistantMessage { .. } => {}
diff --git a/crates/agent_ui/src/acp/message_editor.rs b/crates/agent_ui/src/acp/message_editor.rs
index da121bb7a486d80f15125d2ecc526b3b01e059d3..de5421c0907674cc9c62c6e326239aa9ffc726f2 100644
--- a/crates/agent_ui/src/acp/message_editor.rs
+++ b/crates/agent_ui/src/acp/message_editor.rs
@@ -493,14 +493,13 @@ impl MessageEditor {
         let Some(entry) = self.project.read(cx).entry_for_path(&project_path, cx) else {
             return Task::ready(Err(anyhow!("project entry not found")));
         };
-        let Some(worktree) = self.project.read(cx).worktree_for_entry(entry.id, cx) else {
+        let directory_path = entry.path.clone();
+        let worktree_id = project_path.worktree_id;
+        let Some(worktree) = self.project.read(cx).worktree_for_id(worktree_id, cx) else {
             return Task::ready(Err(anyhow!("worktree not found")));
         };
         let project = self.project.clone();
         cx.spawn(async move |_, cx| {
-            let directory_path = entry.path.clone();
-
-            let worktree_id = worktree.read_with(cx, |worktree, _| worktree.id())?;
             let file_paths = worktree.read_with(cx, |worktree, _cx| {
                 collect_files_in_path(worktree, &directory_path)
             })?;
@@ -700,10 +699,15 @@ impl MessageEditor {
             self.project.read(cx).fs().clone(),
             self.history_store.clone(),
         ));
-        let delegate = AgentServerDelegate::new(self.project.clone(), None, None);
-        let connection = server.connect(Path::new(""), delegate, cx);
+        let delegate = AgentServerDelegate::new(
+            self.project.read(cx).agent_server_store().clone(),
+            self.project.clone(),
+            None,
+            None,
+        );
+        let connection = server.connect(None, delegate, cx);
         cx.spawn(async move |_, cx| {
-            let agent = connection.await?;
+            let (agent, _) = connection.await?;
             let agent = agent.downcast::<agent2::NativeAgentConnection>().unwrap();
             let summary = agent
                 .0
diff --git a/crates/agent_ui/src/acp/model_selector.rs b/crates/agent_ui/src/acp/model_selector.rs
index cbb513696d88bbfcd95e15e051fc69322fd11281..95c0478aa3cf6b1ca78cf391a5bd734820c41454 100644
--- a/crates/agent_ui/src/acp/model_selector.rs
+++ b/crates/agent_ui/src/acp/model_selector.rs
@@ -192,8 +192,10 @@ impl PickerDelegate for AcpModelPickerDelegate {
         }
     }
 
-    fn dismissed(&mut self, _: &mut Window, cx: &mut Context<Picker<Self>>) {
-        cx.emit(DismissEvent);
+    fn dismissed(&mut self, window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        cx.defer_in(window, |picker, window, cx| {
+            picker.set_query("", window, cx);
+        });
     }
 
     fn render_match(
diff --git a/crates/agent_ui/src/acp/model_selector_popover.rs b/crates/agent_ui/src/acp/model_selector_popover.rs
index e8e0d4be7f9dd06f2a7b98761dc2b6287f968ba4..fa771c695ecf8175859d145b8d08d2cf3447a77a 100644
--- a/crates/agent_ui/src/acp/model_selector_popover.rs
+++ b/crates/agent_ui/src/acp/model_selector_popover.rs
@@ -5,7 +5,8 @@ use agent_client_protocol as acp;
 use gpui::{Entity, FocusHandle};
 use picker::popover_menu::PickerPopoverMenu;
 use ui::{
-    ButtonLike, Context, IntoElement, PopoverMenuHandle, SharedString, Tooltip, Window, prelude::*,
+    ButtonLike, Context, IntoElement, PopoverMenuHandle, SharedString, TintColor, Tooltip, Window,
+    prelude::*,
 };
 use zed_actions::agent::ToggleModelSelector;
 
@@ -58,15 +59,22 @@ impl Render for AcpModelSelectorPopover {
 
         let focus_handle = self.focus_handle.clone();
 
+        let color = if self.menu_handle.is_deployed() {
+            Color::Accent
+        } else {
+            Color::Muted
+        };
+
         PickerPopoverMenu::new(
             self.selector.clone(),
             ButtonLike::new("active-model")
                 .when_some(model_icon, |this, icon| {
-                    this.child(Icon::new(icon).color(Color::Muted).size(IconSize::XSmall))
+                    this.child(Icon::new(icon).color(color).size(IconSize::XSmall))
                 })
+                .selected_style(ButtonStyle::Tinted(TintColor::Accent))
                 .child(
                     Label::new(model_name)
-                        .color(Color::Muted)
+                        .color(color)
                         .size(LabelSize::Small)
                         .ml_0p5(),
                 )
diff --git a/crates/agent_ui/src/acp/thread_view.rs b/crates/agent_ui/src/acp/thread_view.rs
index 50da44e430fd684d0e91d43ee82a0ccb0117111d..8627455b4f33029152dc09e63ae868506defb430 100644
--- a/crates/agent_ui/src/acp/thread_view.rs
+++ b/crates/agent_ui/src/acp/thread_view.rs
@@ -6,7 +6,7 @@ use acp_thread::{
 use acp_thread::{AgentConnection, Plan};
 use action_log::ActionLog;
 use agent_client_protocol::{self as acp, PromptCapabilities};
-use agent_servers::{AgentServer, AgentServerDelegate, ClaudeCode};
+use agent_servers::{AgentServer, AgentServerDelegate};
 use agent_settings::{AgentProfileId, AgentSettings, CompletionMode, NotifyWhenAgentWaiting};
 use agent2::{DbThreadMetadata, HistoryEntry, HistoryEntryId, HistoryStore, NativeAgentServer};
 use anyhow::{Context as _, Result, anyhow, bail};
@@ -40,10 +40,9 @@ use std::path::Path;
 use std::sync::Arc;
 use std::time::Instant;
 use std::{collections::BTreeMap, rc::Rc, time::Duration};
-use task::SpawnInTerminal;
 use terminal_view::terminal_panel::TerminalPanel;
 use text::Anchor;
-use theme::ThemeSettings;
+use theme::{AgentFontSize, ThemeSettings};
 use ui::{
     Callout, CommonAnimationExt, Disclosure, Divider, DividerColor, ElevationIndex, KeyBinding,
     PopoverMenuHandle, Scrollbar, ScrollbarState, SpinnerLabel, TintColor, Tooltip, prelude::*,
@@ -263,6 +262,7 @@ pub struct AcpThreadView {
     workspace: WeakEntity<Workspace>,
     project: Entity<Project>,
     thread_state: ThreadState,
+    login: Option<task::SpawnInTerminal>,
     history_store: Entity<HistoryStore>,
     hovered_recent_history_item: Option<usize>,
     entry_view_state: Entity<EntryViewState>,
@@ -290,7 +290,7 @@ pub struct AcpThreadView {
     is_loading_contents: bool,
     new_server_version_available: Option<SharedString>,
     _cancel_task: Option<Task<()>>,
-    _subscriptions: [Subscription; 3],
+    _subscriptions: [Subscription; 4],
 }
 
 enum ThreadState {
@@ -380,7 +380,8 @@ impl AcpThreadView {
         });
 
         let subscriptions = [
-            cx.observe_global_in::<SettingsStore>(window, Self::settings_changed),
+            cx.observe_global_in::<SettingsStore>(window, Self::agent_font_size_changed),
+            cx.observe_global_in::<AgentFontSize>(window, Self::agent_font_size_changed),
             cx.subscribe_in(&message_editor, window, Self::handle_message_editor_event),
             cx.subscribe_in(&entry_view_state, window, Self::handle_entry_view_event),
         ];
@@ -391,6 +392,7 @@ impl AcpThreadView {
             project: project.clone(),
             entry_view_state,
             thread_state: Self::initial_state(agent, resume_thread, workspace, project, window, cx),
+            login: None,
             message_editor,
             model_selector: None,
             profile_selector: None,
@@ -443,9 +445,11 @@ impl AcpThreadView {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> ThreadState {
-        if !project.read(cx).is_local() && agent.clone().downcast::<NativeAgentServer>().is_none() {
+        if project.read(cx).is_via_collab()
+            && agent.clone().downcast::<NativeAgentServer>().is_none()
+        {
             return ThreadState::LoadError(LoadError::Other(
-                "External agents are not yet supported for remote projects.".into(),
+                "External agents are not yet supported in shared projects.".into(),
             ));
         }
         let mut worktrees = project.read(cx).visible_worktrees(cx).collect::<Vec<_>>();
@@ -465,20 +469,23 @@ impl AcpThreadView {
                     Some(worktree.read(cx).abs_path())
                 }
             })
-            .next()
-            .unwrap_or_else(|| paths::home_dir().as_path().into());
+            .next();
         let (status_tx, mut status_rx) = watch::channel("Loading…".into());
         let (new_version_available_tx, mut new_version_available_rx) = watch::channel(None);
         let delegate = AgentServerDelegate::new(
+            project.read(cx).agent_server_store().clone(),
             project.clone(),
             Some(status_tx),
             Some(new_version_available_tx),
         );
 
-        let connect_task = agent.connect(&root_dir, delegate, cx);
+        let connect_task = agent.connect(root_dir.as_deref(), delegate, cx);
         let load_task = cx.spawn_in(window, async move |this, cx| {
             let connection = match connect_task.await {
-                Ok(connection) => connection,
+                Ok((connection, login)) => {
+                    this.update(cx, |this, _| this.login = login).ok();
+                    connection
+                }
                 Err(err) => {
                     this.update_in(cx, |this, window, cx| {
                         if err.downcast_ref::<LoadError>().is_some() {
@@ -505,6 +512,14 @@ impl AcpThreadView {
                 })
                 .log_err()
             } else {
+                let root_dir = if let Some(acp_agent) = connection
+                    .clone()
+                    .downcast::<agent_servers::AcpConnection>()
+                {
+                    acp_agent.root_dir().into()
+                } else {
+                    root_dir.unwrap_or(paths::home_dir().as_path().into())
+                };
                 cx.update(|_, cx| {
                     connection
                         .clone()
@@ -912,7 +927,7 @@ impl AcpThreadView {
                 }
             }
             ViewEvent::MessageEditorEvent(editor, MessageEditorEvent::Send) => {
-                self.regenerate(event.entry_index, editor, window, cx);
+                self.regenerate(event.entry_index, editor.clone(), window, cx);
             }
             ViewEvent::MessageEditorEvent(_editor, MessageEditorEvent::Cancel) => {
                 self.cancel_editing(&Default::default(), window, cx);
@@ -983,7 +998,7 @@ impl AcpThreadView {
                     this,
                     AuthRequired {
                         description: None,
-                        provider_id: Some(language_model::ANTHROPIC_PROVIDER_ID),
+                        provider_id: None,
                     },
                     agent,
                     connection,
@@ -1136,7 +1151,7 @@ impl AcpThreadView {
     fn regenerate(
         &mut self,
         entry_ix: usize,
-        message_editor: &Entity<MessageEditor>,
+        message_editor: Entity<MessageEditor>,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
@@ -1153,16 +1168,18 @@ impl AcpThreadView {
             return;
         };
 
-        let contents = message_editor.update(cx, |message_editor, cx| message_editor.contents(cx));
-
-        let task = cx.spawn(async move |_, cx| {
-            let contents = contents.await?;
+        cx.spawn_in(window, async move |this, cx| {
             thread
                 .update(cx, |thread, cx| thread.rewind(user_message_id, cx))?
                 .await?;
-            Ok(contents)
-        });
-        self.send_impl(task, window, cx);
+            let contents =
+                message_editor.update(cx, |message_editor, cx| message_editor.contents(cx))?;
+            this.update_in(cx, |this, window, cx| {
+                this.send_impl(contents, window, cx);
+            })?;
+            anyhow::Ok(())
+        })
+        .detach();
     }
 
     fn open_agent_diff(&mut self, _: &OpenAgentDiff, window: &mut Window, cx: &mut Context<Self>) {
@@ -1461,9 +1478,12 @@ impl AcpThreadView {
         self.thread_error.take();
         configuration_view.take();
         pending_auth_method.replace(method.clone());
-        let authenticate = if method.0.as_ref() == "claude-login" {
+        let authenticate = if (method.0.as_ref() == "claude-login"
+            || method.0.as_ref() == "spawn-gemini-cli")
+            && let Some(login) = self.login.clone()
+        {
             if let Some(workspace) = self.workspace.upgrade() {
-                Self::spawn_claude_login(&workspace, window, cx)
+                Self::spawn_external_agent_login(login, workspace, false, window, cx)
             } else {
                 Task::ready(Ok(()))
             }
@@ -1510,31 +1530,28 @@ impl AcpThreadView {
             }));
     }
 
-    fn spawn_claude_login(
-        workspace: &Entity<Workspace>,
+    fn spawn_external_agent_login(
+        login: task::SpawnInTerminal,
+        workspace: Entity<Workspace>,
+        previous_attempt: bool,
         window: &mut Window,
         cx: &mut App,
     ) -> Task<Result<()>> {
         let Some(terminal_panel) = workspace.read(cx).panel::<TerminalPanel>(cx) else {
             return Task::ready(Ok(()));
         };
-        let project_entity = workspace.read(cx).project();
-        let project = project_entity.read(cx);
-        let cwd = project.first_project_directory(cx);
-        let shell = project.terminal_settings(&cwd, cx).shell.clone();
-
-        let delegate = AgentServerDelegate::new(project_entity.clone(), None, None);
-        let command = ClaudeCode::login_command(delegate, cx);
+        let project = workspace.read(cx).project().clone();
+        let cwd = project.read(cx).first_project_directory(cx);
+        let shell = project.read(cx).terminal_settings(&cwd, cx).shell.clone();
 
         window.spawn(cx, async move |cx| {
-            let login_command = command.await?;
-            let command = login_command
-                .path
-                .to_str()
-                .with_context(|| format!("invalid login command: {:?}", login_command.path))?;
-            let command = shlex::try_quote(command)?;
-            let args = login_command
-                .arguments
+            let mut task = login.clone();
+            task.command = task
+                .command
+                .map(|command| anyhow::Ok(shlex::try_quote(&command)?.to_string()))
+                .transpose()?;
+            task.args = task
+                .args
                 .iter()
                 .map(|arg| {
                     Ok(shlex::try_quote(arg)
@@ -1542,26 +1559,16 @@ impl AcpThreadView {
                         .to_string())
                 })
                 .collect::<Result<Vec<_>>>()?;
+            task.full_label = task.label.clone();
+            task.id = task::TaskId(format!("external-agent-{}-login", task.label));
+            task.command_label = task.label.clone();
+            task.use_new_terminal = true;
+            task.allow_concurrent_runs = true;
+            task.hide = task::HideStrategy::Always;
+            task.shell = shell;
 
             let terminal = terminal_panel.update_in(cx, |terminal_panel, window, cx| {
-                terminal_panel.spawn_task(
-                    &SpawnInTerminal {
-                        id: task::TaskId("claude-login".into()),
-                        full_label: "claude /login".to_owned(),
-                        label: "claude /login".to_owned(),
-                        command: Some(command.into()),
-                        args,
-                        command_label: "claude /login".to_owned(),
-                        cwd,
-                        use_new_terminal: true,
-                        allow_concurrent_runs: true,
-                        hide: task::HideStrategy::Always,
-                        shell,
-                        ..Default::default()
-                    },
-                    window,
-                    cx,
-                )
+                terminal_panel.spawn_task(&login, window, cx)
             })?;
 
             let terminal = terminal.await?;
@@ -1577,7 +1584,9 @@ impl AcpThreadView {
                             cx.background_executor().timer(Duration::from_secs(1)).await;
                             let content =
                                 terminal.update(cx, |terminal, _cx| terminal.get_content())?;
-                            if content.contains("Login successful") {
+                            if content.contains("Login successful")
+                                || content.contains("Type your message")
+                            {
                                 return anyhow::Ok(());
                             }
                         }
@@ -1593,6 +1602,9 @@ impl AcpThreadView {
                     }
                 }
                 _ = exit_status => {
+                    if !previous_attempt && project.read_with(cx, |project, _| project.is_via_remote_server())? && login.label.contains("gemini") {
+                        return cx.update(|window, cx| Self::spawn_external_agent_login(login, workspace, true, window, cx))?.await
+                    }
                     return Err(anyhow!("exited before logging in"));
                 }
             }
@@ -1625,14 +1637,16 @@ impl AcpThreadView {
         cx.notify();
     }
 
-    fn rewind(&mut self, message_id: &UserMessageId, cx: &mut Context<Self>) {
+    fn restore_checkpoint(&mut self, message_id: &UserMessageId, cx: &mut Context<Self>) {
         let Some(thread) = self.thread() else {
             return;
         };
+
         thread
-            .update(cx, |thread, cx| thread.rewind(message_id.clone(), cx))
+            .update(cx, |thread, cx| {
+                thread.restore_checkpoint(message_id.clone(), cx)
+            })
             .detach_and_log_err(cx);
-        cx.notify();
     }
 
     fn render_entry(
@@ -1702,8 +1716,9 @@ impl AcpThreadView {
                                         .label_size(LabelSize::XSmall)
                                         .icon_color(Color::Muted)
                                         .color(Color::Muted)
+                                        .tooltip(Tooltip::text("Restores all files in the project to the content they had at this point in the conversation."))
                                         .on_click(cx.listener(move |this, _, _window, cx| {
-                                            this.rewind(&message_id, cx);
+                                            this.restore_checkpoint(&message_id, cx);
                                         }))
                                 )
                                 .child(Divider::horizontal())
@@ -1774,7 +1789,7 @@ impl AcpThreadView {
                                                             let editor = editor.clone();
                                                             move |this, _, window, cx| {
                                                                 this.regenerate(
-                                                                    entry_ix, &editor, window, cx,
+                                                                    entry_ix, editor.clone(), window, cx,
                                                                 );
                                                             }
                                                         })).into_any_element()
@@ -2023,35 +2038,34 @@ impl AcpThreadView {
         window: &Window,
         cx: &Context<Self>,
     ) -> Div {
+        let has_location = tool_call.locations.len() == 1;
         let card_header_id = SharedString::from("inner-tool-call-header");
 
-        let tool_icon =
-            if tool_call.kind == acp::ToolKind::Edit && tool_call.locations.len() == 1 {
-                FileIcons::get_icon(&tool_call.locations[0].path, cx)
-                    .map(Icon::from_path)
-                    .unwrap_or(Icon::new(IconName::ToolPencil))
-            } else {
-                Icon::new(match tool_call.kind {
-                    acp::ToolKind::Read => IconName::ToolSearch,
-                    acp::ToolKind::Edit => IconName::ToolPencil,
-                    acp::ToolKind::Delete => IconName::ToolDeleteFile,
-                    acp::ToolKind::Move => IconName::ArrowRightLeft,
-                    acp::ToolKind::Search => IconName::ToolSearch,
-                    acp::ToolKind::Execute => IconName::ToolTerminal,
-                    acp::ToolKind::Think => IconName::ToolThink,
-                    acp::ToolKind::Fetch => IconName::ToolWeb,
-                    acp::ToolKind::Other => IconName::ToolHammer,
-                })
-            }
-            .size(IconSize::Small)
-            .color(Color::Muted);
+        let tool_icon = if tool_call.kind == acp::ToolKind::Edit && has_location {
+            FileIcons::get_icon(&tool_call.locations[0].path, cx)
+                .map(Icon::from_path)
+                .unwrap_or(Icon::new(IconName::ToolPencil))
+        } else {
+            Icon::new(match tool_call.kind {
+                acp::ToolKind::Read => IconName::ToolSearch,
+                acp::ToolKind::Edit => IconName::ToolPencil,
+                acp::ToolKind::Delete => IconName::ToolDeleteFile,
+                acp::ToolKind::Move => IconName::ArrowRightLeft,
+                acp::ToolKind::Search => IconName::ToolSearch,
+                acp::ToolKind::Execute => IconName::ToolTerminal,
+                acp::ToolKind::Think => IconName::ToolThink,
+                acp::ToolKind::Fetch => IconName::ToolWeb,
+                acp::ToolKind::Other => IconName::ToolHammer,
+            })
+        }
+        .size(IconSize::Small)
+        .color(Color::Muted);
 
         let failed_or_canceled = match &tool_call.status {
             ToolCallStatus::Rejected | ToolCallStatus::Canceled | ToolCallStatus::Failed => true,
             _ => false,
         };
 
-        let has_location = tool_call.locations.len() == 1;
         let needs_confirmation = matches!(
             tool_call.status,
             ToolCallStatus::WaitingForConfirmation { .. }
@@ -2194,13 +2208,6 @@ impl AcpThreadView {
                             .overflow_hidden()
                             .child(tool_icon)
                             .child(if has_location {
-                                let name = tool_call.locations[0]
-                                    .path
-                                    .file_name()
-                                    .unwrap_or_default()
-                                    .display()
-                                    .to_string();
-
                                 h_flex()
                                     .id(("open-tool-call-location", entry_ix))
                                     .w_full()
@@ -2211,7 +2218,13 @@ impl AcpThreadView {
                                             this.text_color(cx.theme().colors().text_muted)
                                         }
                                     })
-                                    .child(name)
+                                    .child(self.render_markdown(
+                                        tool_call.label.clone(),
+                                        MarkdownStyle {
+                                            prevent_mouse_interaction: true,
+                                            ..default_markdown_style(false, true, window, cx)
+                                        },
+                                    ))
                                     .tooltip(Tooltip::text("Jump to File"))
                                     .on_click(cx.listener(move |this, _, window, cx| {
                                         this.open_tool_call_location(entry_ix, 0, window, cx);
@@ -3010,6 +3023,8 @@ impl AcpThreadView {
         let show_description =
             configuration_view.is_none() && description.is_none() && pending_auth_method.is_none();
 
+        let auth_methods = connection.auth_methods();
+
         v_flex().flex_1().size_full().justify_end().child(
             v_flex()
                 .p_2()
@@ -3040,21 +3055,23 @@ impl AcpThreadView {
                         .cloned()
                         .map(|view| div().w_full().child(view)),
                 )
-                .when(
-                    show_description,
-                    |el| {
-                        el.child(
-                            Label::new(format!(
-                                "You are not currently authenticated with {}. Please choose one of the following options:",
-                                self.agent.name()
-                            ))
-                            .size(LabelSize::Small)
-                            .color(Color::Muted)
-                            .mb_1()
-                            .ml_5(),
-                        )
-                    },
-                )
+                .when(show_description, |el| {
+                    el.child(
+                        Label::new(format!(
+                            "You are not currently authenticated with {}.{}",
+                            self.agent.name(),
+                            if auth_methods.len() > 1 {
+                                " Please choose one of the following options:"
+                            } else {
+                                ""
+                            }
+                        ))
+                        .size(LabelSize::Small)
+                        .color(Color::Muted)
+                        .mb_1()
+                        .ml_5(),
+                    )
+                })
                 .when_some(pending_auth_method, |el, _| {
                     el.child(
                         h_flex()
@@ -3066,12 +3083,12 @@ impl AcpThreadView {
                                 Icon::new(IconName::ArrowCircle)
                                     .size(IconSize::Small)
                                     .color(Color::Muted)
-                                    .with_rotate_animation(2)
+                                    .with_rotate_animation(2),
                             )
                             .child(Label::new("Authenticating…").size(LabelSize::Small)),
                     )
                 })
-                .when(!connection.auth_methods().is_empty(), |this| {
+                .when(!auth_methods.is_empty(), |this| {
                     this.child(
                         h_flex()
                             .justify_end()
@@ -3083,23 +3100,26 @@ impl AcpThreadView {
                                     .pt_2()
                                     .border_color(cx.theme().colors().border.opacity(0.8))
                             })
-                            .children(
-                                connection
-                                    .auth_methods()
-                                    .iter()
-                                    .enumerate()
-                                    .rev()
-                                    .map(|(ix, method)| {
-                                        Button::new(
-                                            SharedString::from(method.id.0.clone()),
-                                            method.name.clone(),
-                                        )
+                            .children(connection.auth_methods().iter().enumerate().rev().map(
+                                |(ix, method)| {
+                                    let (method_id, name) = if self
+                                        .project
+                                        .read(cx)
+                                        .is_via_remote_server()
+                                        && method.id.0.as_ref() == "oauth-personal"
+                                        && method.name == "Log in with Google"
+                                    {
+                                        ("spawn-gemini-cli".into(), "Log in with Gemini CLI".into())
+                                    } else {
+                                        (method.id.0.clone(), method.name.clone())
+                                    };
+
+                                    Button::new(SharedString::from(method_id.clone()), name)
                                         .when(ix == 0, |el| {
                                             el.style(ButtonStyle::Tinted(ui::TintColor::Warning))
                                         })
                                         .label_size(LabelSize::Small)
                                         .on_click({
-                                            let method_id = method.id.clone();
                                             cx.listener(move |this, _, window, cx| {
                                                 telemetry::event!(
                                                     "Authenticate Agent Started",
@@ -3107,14 +3127,17 @@ impl AcpThreadView {
                                                     method = method_id
                                                 );
 
-                                                this.authenticate(method_id.clone(), window, cx)
+                                                this.authenticate(
+                                                    acp::AuthMethodId(method_id.clone()),
+                                                    window,
+                                                    cx,
+                                                )
                                             })
                                         })
-                                    }),
-                            ),
+                                },
+                            )),
                     )
-                })
-
+                }),
         )
     }
 
@@ -4071,15 +4094,15 @@ impl AcpThreadView {
                 MentionUri::PastedImage => {}
                 MentionUri::Directory { abs_path } => {
                     let project = workspace.project();
-                    let Some(entry) = project.update(cx, |project, cx| {
+                    let Some(entry_id) = project.update(cx, |project, cx| {
                         let path = project.find_project_path(abs_path, cx)?;
-                        project.entry_for_path(&path, cx)
+                        project.entry_for_path(&path, cx).map(|entry| entry.id)
                     }) else {
                         return;
                     };
 
                     project.update(cx, |_, cx| {
-                        cx.emit(project::Event::RevealInProjectPanel(entry.id));
+                        cx.emit(project::Event::RevealInProjectPanel(entry_id));
                     });
                 }
                 MentionUri::Symbol {
@@ -4092,11 +4115,9 @@ impl AcpThreadView {
                     line_range,
                 } => {
                     let project = workspace.project();
-                    let Some((path, _)) = project.update(cx, |project, cx| {
-                        let path = project.find_project_path(path, cx)?;
-                        let entry = project.entry_for_path(&path, cx)?;
-                        Some((path, entry))
-                    }) else {
+                    let Some(path) =
+                        project.update(cx, |project, cx| project.find_project_path(path, cx))
+                    else {
                         return;
                     };
 
@@ -4258,7 +4279,7 @@ impl AcpThreadView {
                 }
 
                 let buffer = project.update(cx, |project, cx| {
-                    project.create_local_buffer(&markdown, Some(markdown_language), cx)
+                    project.create_local_buffer(&markdown, Some(markdown_language), true, cx)
                 });
                 let buffer = cx.new(|cx| {
                     MultiBuffer::singleton(buffer, cx).with_title(thread_summary.clone())
@@ -4737,9 +4758,9 @@ impl AcpThreadView {
         )
     }
 
-    fn settings_changed(&mut self, _window: &mut Window, cx: &mut Context<Self>) {
+    fn agent_font_size_changed(&mut self, _window: &mut Window, cx: &mut Context<Self>) {
         self.entry_view_state.update(cx, |entry_view_state, cx| {
-            entry_view_state.settings_changed(cx);
+            entry_view_state.agent_font_size_changed(cx);
         });
     }
 
@@ -4989,6 +5010,7 @@ impl AcpThreadView {
             cloud_llm_client::Plan::ZedProTrial | cloud_llm_client::Plan::ZedFree => {
                 "Upgrade to Zed Pro for more prompts."
             }
+            cloud_llm_client::Plan::ZedProV2 | cloud_llm_client::Plan::ZedProTrialV2 => "",
         };
 
         Callout::new()
@@ -5715,11 +5737,11 @@ pub(crate) mod tests {
 
         fn connect(
             &self,
-            _root_dir: &Path,
+            _root_dir: Option<&Path>,
             _delegate: AgentServerDelegate,
             _cx: &mut App,
-        ) -> Task<gpui::Result<Rc<dyn AgentConnection>>> {
-            Task::ready(Ok(Rc::new(self.connection.clone())))
+        ) -> Task<gpui::Result<(Rc<dyn AgentConnection>, Option<task::SpawnInTerminal>)>> {
+            Task::ready(Ok((Rc::new(self.connection.clone()), None)))
         }
 
         fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
diff --git a/crates/agent_ui/src/active_thread.rs b/crates/agent_ui/src/active_thread.rs
index fbba3eaffdd818bd1496b83f9f3081cbf52735ed..dad2e282a515071405de789ef4cb0268cc672d8a 100644
--- a/crates/agent_ui/src/active_thread.rs
+++ b/crates/agent_ui/src/active_thread.rs
@@ -3585,7 +3585,7 @@ pub(crate) fn open_active_thread_as_markdown(
             }
 
             let buffer = project.update(cx, |project, cx| {
-                project.create_local_buffer(&markdown, Some(markdown_language), cx)
+                project.create_local_buffer(&markdown, Some(markdown_language), true, cx)
             });
             let buffer =
                 cx.new(|cx| MultiBuffer::singleton(buffer, cx).with_title(thread_summary.clone()));
diff --git a/crates/agent_ui/src/agent_configuration.rs b/crates/agent_ui/src/agent_configuration.rs
index 5981a3c52bf52ff4549b2f73a6322e308725750d..bc7dd1d55296075a375eb6f98662d9a626636ef7 100644
--- a/crates/agent_ui/src/agent_configuration.rs
+++ b/crates/agent_ui/src/agent_configuration.rs
@@ -5,7 +5,6 @@ mod tool_picker;
 
 use std::{ops::Range, sync::Arc};
 
-use agent_servers::{AgentServerCommand, AllAgentServersSettings, CustomAgentServerSettings};
 use agent_settings::AgentSettings;
 use anyhow::Result;
 use assistant_tool::{ToolSource, ToolWorkingSet};
@@ -26,6 +25,10 @@ use language_model::{
 };
 use notifications::status_toast::{StatusToast, ToastIcon};
 use project::{
+    agent_server_store::{
+        AgentServerCommand, AgentServerStore, AllAgentServersSettings, CLAUDE_CODE_NAME,
+        CustomAgentServerSettings, GEMINI_NAME,
+    },
     context_server_store::{ContextServerConfiguration, ContextServerStatus, ContextServerStore},
     project_settings::{ContextServerSettings, ProjectSettings},
 };
@@ -45,11 +48,13 @@ pub(crate) use manage_profiles_modal::ManageProfilesModal;
 use crate::{
     AddContextServer, ExternalAgent, NewExternalAgentThread,
     agent_configuration::add_llm_provider_modal::{AddLlmProviderModal, LlmCompatibleProvider},
+    placeholder_command,
 };
 
 pub struct AgentConfiguration {
     fs: Arc<dyn Fs>,
     language_registry: Arc<LanguageRegistry>,
+    agent_server_store: Entity<AgentServerStore>,
     workspace: WeakEntity<Workspace>,
     focus_handle: FocusHandle,
     configuration_views_by_provider: HashMap<LanguageModelProviderId, AnyView>,
@@ -66,6 +71,7 @@ pub struct AgentConfiguration {
 impl AgentConfiguration {
     pub fn new(
         fs: Arc<dyn Fs>,
+        agent_server_store: Entity<AgentServerStore>,
         context_server_store: Entity<ContextServerStore>,
         tools: Entity<ToolWorkingSet>,
         language_registry: Arc<LanguageRegistry>,
@@ -104,6 +110,7 @@ impl AgentConfiguration {
             workspace,
             focus_handle,
             configuration_views_by_provider: HashMap::default(),
+            agent_server_store,
             context_server_store,
             expanded_context_server_tools: HashMap::default(),
             expanded_provider_configurations: HashMap::default(),
@@ -509,8 +516,10 @@ impl AgentConfiguration {
 
             let (plan_name, label_color, bg_color) = match plan {
                 Plan::ZedFree => ("Free", Color::Default, free_chip_bg),
-                Plan::ZedProTrial => ("Pro Trial", Color::Accent, pro_chip_bg),
-                Plan::ZedPro => ("Pro", Color::Accent, pro_chip_bg),
+                Plan::ZedProTrial | Plan::ZedProTrialV2 => {
+                    ("Pro Trial", Color::Accent, pro_chip_bg)
+                }
+                Plan::ZedPro | Plan::ZedProV2 => ("Pro", Color::Accent, pro_chip_bg),
             };
 
             Chip::new(plan_name.to_string())
@@ -991,17 +1000,30 @@ impl AgentConfiguration {
     }
 
     fn render_agent_servers_section(&mut self, cx: &mut Context<Self>) -> impl IntoElement {
-        let settings = AllAgentServersSettings::get_global(cx).clone();
-        let user_defined_agents = settings
+        let custom_settings = cx
+            .global::<SettingsStore>()
+            .get::<AllAgentServersSettings>(None)
             .custom
-            .iter()
-            .map(|(name, settings)| {
+            .clone();
+        let user_defined_agents = self
+            .agent_server_store
+            .read(cx)
+            .external_agents()
+            .filter(|name| name.0 != GEMINI_NAME && name.0 != CLAUDE_CODE_NAME)
+            .cloned()
+            .collect::<Vec<_>>();
+        let user_defined_agents = user_defined_agents
+            .into_iter()
+            .map(|name| {
                 self.render_agent_server(
                     IconName::Ai,
                     name.clone(),
                     ExternalAgent::Custom {
-                        name: name.clone(),
-                        command: settings.command.clone(),
+                        name: name.clone().into(),
+                        command: custom_settings
+                            .get(&name.0)
+                            .map(|settings| settings.command.clone())
+                            .unwrap_or(placeholder_command()),
                     },
                     cx,
                 )
diff --git a/crates/agent_ui/src/agent_configuration/configure_context_server_modal.rs b/crates/agent_ui/src/agent_configuration/configure_context_server_modal.rs
index e5027b876ac0f996e1f4df2a61af1477c6490c10..4d338840143fbcf007f7d5c66e2406ef4bb9fc88 100644
--- a/crates/agent_ui/src/agent_configuration/configure_context_server_modal.rs
+++ b/crates/agent_ui/src/agent_configuration/configure_context_server_modal.rs
@@ -251,6 +251,7 @@ pub struct ConfigureContextServerModal {
     workspace: WeakEntity<Workspace>,
     source: ConfigurationSource,
     state: State,
+    original_server_id: Option<ContextServerId>,
 }
 
 impl ConfigureContextServerModal {
@@ -348,6 +349,11 @@ impl ConfigureContextServerModal {
                     context_server_store,
                     workspace: workspace_handle,
                     state: State::Idle,
+                    original_server_id: match &target {
+                        ConfigurationTarget::Existing { id, .. } => Some(id.clone()),
+                        ConfigurationTarget::Extension { id, .. } => Some(id.clone()),
+                        ConfigurationTarget::New => None,
+                    },
                     source: ConfigurationSource::from_target(
                         target,
                         language_registry,
@@ -415,9 +421,19 @@ impl ConfigureContextServerModal {
             // When we write the settings to the file, the context server will be restarted.
             workspace.update(cx, |workspace, cx| {
                 let fs = workspace.app_state().fs.clone();
-                update_settings_file::<ProjectSettings>(fs.clone(), cx, |project_settings, _| {
-                    project_settings.context_servers.insert(id.0, settings);
-                });
+                let original_server_id = self.original_server_id.clone();
+                update_settings_file::<ProjectSettings>(
+                    fs.clone(),
+                    cx,
+                    move |project_settings, _| {
+                        if let Some(original_id) = original_server_id {
+                            if original_id != id {
+                                project_settings.context_servers.remove(&original_id.0);
+                            }
+                        }
+                        project_settings.context_servers.insert(id.0, settings);
+                    },
+                );
             });
         } else if let Some(existing_server) = existing_server {
             self.context_server_store
diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs
index d021eaefb5ebff43fad1fe4822b3758550a0179f..67a0988f7fb4a49a5f2453fd57beb52c3e2dd16b 100644
--- a/crates/agent_ui/src/agent_panel.rs
+++ b/crates/agent_ui/src/agent_panel.rs
@@ -5,9 +5,11 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use acp_thread::AcpThread;
-use agent_servers::AgentServerCommand;
 use agent2::{DbThreadMetadata, HistoryEntry};
 use db::kvp::{Dismissable, KEY_VALUE_STORE};
+use project::agent_server_store::{
+    AgentServerCommand, AllAgentServersSettings, CLAUDE_CODE_NAME, GEMINI_NAME,
+};
 use serde::{Deserialize, Serialize};
 use zed_actions::OpenBrowser;
 use zed_actions::agent::{OpenClaudeCodeOnboardingModal, ReauthenticateAgent};
@@ -33,7 +35,9 @@ use crate::{
     thread_history::{HistoryEntryElement, ThreadHistory},
     ui::{AgentOnboardingModal, EndTrialUpsell},
 };
-use crate::{ExternalAgent, NewExternalAgentThread, NewNativeAgentThreadFromSummary};
+use crate::{
+    ExternalAgent, NewExternalAgentThread, NewNativeAgentThreadFromSummary, placeholder_command,
+};
 use agent::{
     Thread, ThreadError, ThreadEvent, ThreadId, ThreadSummary, TokenUsageRatio,
     context_store::ContextStore,
@@ -62,7 +66,7 @@ use project::{DisableAiSettings, Project, ProjectPath, Worktree};
 use prompt_store::{PromptBuilder, PromptStore, UserPromptId};
 use rules_library::{RulesLibrary, open_rules_library};
 use search::{BufferSearchBar, buffer_search};
-use settings::{Settings, update_settings_file};
+use settings::{Settings, SettingsStore, update_settings_file};
 use theme::ThemeSettings;
 use time::UtcOffset;
 use ui::utils::WithRemSize;
@@ -1094,7 +1098,7 @@ impl AgentPanel {
         let workspace = self.workspace.clone();
         let project = self.project.clone();
         let fs = self.fs.clone();
-        let is_not_local = !self.project.read(cx).is_local();
+        let is_via_collab = self.project.read(cx).is_via_collab();
 
         const LAST_USED_EXTERNAL_AGENT_KEY: &str = "agent_panel__last_used_external_agent";
 
@@ -1126,7 +1130,7 @@ impl AgentPanel {
                     agent
                 }
                 None => {
-                    if is_not_local {
+                    if is_via_collab {
                         ExternalAgent::NativeAgent
                     } else {
                         cx.background_spawn(async move {
@@ -1503,6 +1507,7 @@ impl AgentPanel {
     }
 
     pub(crate) fn open_configuration(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let agent_server_store = self.project.read(cx).agent_server_store().clone();
         let context_server_store = self.project.read(cx).context_server_store();
         let tools = self.thread_store.read(cx).tools();
         let fs = self.fs.clone();
@@ -1511,6 +1516,7 @@ impl AgentPanel {
         self.configuration = Some(cx.new(|cx| {
             AgentConfiguration::new(
                 fs,
+                agent_server_store,
                 context_server_store,
                 tools,
                 self.language_registry.clone(),
@@ -2503,6 +2509,7 @@ impl AgentPanel {
     }
 
     fn render_toolbar_new(&self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let agent_server_store = self.project.read(cx).agent_server_store().clone();
         let focus_handle = self.focus_handle(cx);
 
         let active_thread = match &self.active_view {
@@ -2531,12 +2538,14 @@ impl AgentPanel {
                     }
                 },
             )
-            .anchor(Corner::TopLeft)
+            .anchor(Corner::TopRight)
             .with_handle(self.new_thread_menu_handle.clone())
             .menu({
                 let workspace = self.workspace.clone();
-                let is_not_local = workspace
-                    .update(cx, |workspace, cx| !workspace.project().read(cx).is_local())
+                let is_via_collab = workspace
+                    .update(cx, |workspace, cx| {
+                        workspace.project().read(cx).is_via_collab()
+                    })
                     .unwrap_or_default();
 
                 move |window, cx| {
@@ -2628,7 +2637,7 @@ impl AgentPanel {
                                     ContextMenuEntry::new("New Gemini CLI Thread")
                                         .icon(IconName::AiGemini)
                                         .icon_color(Color::Muted)
-                                        .disabled(is_not_local)
+                                        .disabled(is_via_collab)
                                         .handler({
                                             let workspace = workspace.clone();
                                             move |window, cx| {
@@ -2655,7 +2664,7 @@ impl AgentPanel {
                                 menu.item(
                                     ContextMenuEntry::new("New Claude Code Thread")
                                         .icon(IconName::AiClaude)
-                                        .disabled(is_not_local)
+                                        .disabled(is_via_collab)
                                         .icon_color(Color::Muted)
                                         .handler({
                                             let workspace = workspace.clone();
@@ -2680,19 +2689,25 @@ impl AgentPanel {
                                 )
                             })
                             .when(cx.has_flag::<GeminiAndNativeFeatureFlag>(), |mut menu| {
-                                // Add custom agents from settings
-                                let settings =
-                                    agent_servers::AllAgentServersSettings::get_global(cx);
-                                for (agent_name, agent_settings) in &settings.custom {
+                                let agent_names = agent_server_store
+                                    .read(cx)
+                                    .external_agents()
+                                    .filter(|name| {
+                                        name.0 != GEMINI_NAME && name.0 != CLAUDE_CODE_NAME
+                                    })
+                                    .cloned()
+                                    .collect::<Vec<_>>();
+                                let custom_settings = cx.global::<SettingsStore>().get::<AllAgentServersSettings>(None).custom.clone();
+                                for agent_name in agent_names {
                                     menu = menu.item(
                                         ContextMenuEntry::new(format!("New {} Thread", agent_name))
                                             .icon(IconName::Terminal)
                                             .icon_color(Color::Muted)
-                                            .disabled(is_not_local)
+                                            .disabled(is_via_collab)
                                             .handler({
                                                 let workspace = workspace.clone();
                                                 let agent_name = agent_name.clone();
-                                                let agent_settings = agent_settings.clone();
+                                                let custom_settings = custom_settings.clone();
                                                 move |window, cx| {
                                                     if let Some(workspace) = workspace.upgrade() {
                                                         workspace.update(cx, |workspace, cx| {
@@ -2703,10 +2718,9 @@ impl AgentPanel {
                                                                     panel.new_agent_thread(
                                                                         AgentType::Custom {
                                                                             name: agent_name
-                                                                                .clone(),
-                                                                            command: agent_settings
-                                                                                .command
-                                                                                .clone(),
+                                                                                .clone()
+                                                                                .into(),
+                                                                            command: custom_settings.get(&agent_name.0).map(|settings| settings.command.clone()).unwrap_or(placeholder_command())
                                                                         },
                                                                         window,
                                                                         cx,
@@ -3504,6 +3518,7 @@ impl AgentPanel {
         let error_message = match plan {
             Plan::ZedPro => "Upgrade to usage-based billing for more prompts.",
             Plan::ZedProTrial | Plan::ZedFree => "Upgrade to Zed Pro for more prompts.",
+            Plan::ZedProV2 | Plan::ZedProTrialV2 => "",
         };
 
         Callout::new()
diff --git a/crates/agent_ui/src/agent_ui.rs b/crates/agent_ui/src/agent_ui.rs
index 93a4a8f748eefc933f809669af841f443888f7ed..b16643854ee213c9d0f4370e422b012c1deebd9d 100644
--- a/crates/agent_ui/src/agent_ui.rs
+++ b/crates/agent_ui/src/agent_ui.rs
@@ -28,7 +28,6 @@ use std::rc::Rc;
 use std::sync::Arc;
 
 use agent::{Thread, ThreadId};
-use agent_servers::AgentServerCommand;
 use agent_settings::{AgentProfileId, AgentSettings, LanguageModelSelection};
 use assistant_slash_command::SlashCommandRegistry;
 use client::Client;
@@ -41,6 +40,7 @@ use language_model::{
     ConfiguredModel, LanguageModel, LanguageModelId, LanguageModelProviderId, LanguageModelRegistry,
 };
 use project::DisableAiSettings;
+use project::agent_server_store::AgentServerCommand;
 use prompt_store::PromptBuilder;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -174,6 +174,14 @@ enum ExternalAgent {
     },
 }
 
+fn placeholder_command() -> AgentServerCommand {
+    AgentServerCommand {
+        path: "/placeholder".into(),
+        args: vec![],
+        env: None,
+    }
+}
+
 impl ExternalAgent {
     fn name(&self) -> &'static str {
         match self {
@@ -193,10 +201,9 @@ impl ExternalAgent {
             Self::Gemini => Rc::new(agent_servers::Gemini),
             Self::ClaudeCode => Rc::new(agent_servers::ClaudeCode),
             Self::NativeAgent => Rc::new(agent2::NativeAgentServer::new(fs, history)),
-            Self::Custom { name, command } => Rc::new(agent_servers::CustomAgentServer::new(
-                name.clone(),
-                command.clone(),
-            )),
+            Self::Custom { name, command: _ } => {
+                Rc::new(agent_servers::CustomAgentServer::new(name.clone()))
+            }
         }
     }
 }
@@ -337,8 +344,7 @@ fn update_command_palette_filter(cx: &mut App) {
             ];
             filter.show_action_types(edit_prediction_actions.iter());
 
-            filter
-                .show_action_types([TypeId::of::<zed_actions::OpenZedPredictOnboarding>()].iter());
+            filter.show_action_types(&[TypeId::of::<zed_actions::OpenZedPredictOnboarding>()]);
         }
     });
 }
diff --git a/crates/agent_ui/src/buffer_codegen.rs b/crates/agent_ui/src/buffer_codegen.rs
index 04eb41793f2257a9dccfdd089594d2f90d0ce513..2309aad754aee55af5ad040c39d22304486446a4 100644
--- a/crates/agent_ui/src/buffer_codegen.rs
+++ b/crates/agent_ui/src/buffer_codegen.rs
@@ -1139,7 +1139,7 @@ mod tests {
         );
         while !new_text.is_empty() {
             let max_len = cmp::min(new_text.len(), 10);
-            let len = rng.gen_range(1..=max_len);
+            let len = rng.random_range(1..=max_len);
             let (chunk, suffix) = new_text.split_at(len);
             chunks_tx.unbounded_send(chunk.to_string()).unwrap();
             new_text = suffix;
@@ -1208,7 +1208,7 @@ mod tests {
         );
         while !new_text.is_empty() {
             let max_len = cmp::min(new_text.len(), 10);
-            let len = rng.gen_range(1..=max_len);
+            let len = rng.random_range(1..=max_len);
             let (chunk, suffix) = new_text.split_at(len);
             chunks_tx.unbounded_send(chunk.to_string()).unwrap();
             new_text = suffix;
@@ -1277,7 +1277,7 @@ mod tests {
         );
         while !new_text.is_empty() {
             let max_len = cmp::min(new_text.len(), 10);
-            let len = rng.gen_range(1..=max_len);
+            let len = rng.random_range(1..=max_len);
             let (chunk, suffix) = new_text.split_at(len);
             chunks_tx.unbounded_send(chunk.to_string()).unwrap();
             new_text = suffix;
diff --git a/crates/agent_ui/src/context_picker.rs b/crates/agent_ui/src/context_picker.rs
index 405b5ed90ba1606ef97b8b048b959bfc354bc5cd..b225fbf34058604cfb3f306a9cee14f69bb5edaa 100644
--- a/crates/agent_ui/src/context_picker.rs
+++ b/crates/agent_ui/src/context_picker.rs
@@ -987,7 +987,8 @@ impl MentionLink {
                     .read(cx)
                     .project()
                     .read(cx)
-                    .entry_for_path(&project_path, cx)?;
+                    .entry_for_path(&project_path, cx)?
+                    .clone();
                 Some(MentionLink::File(project_path, entry))
             }
             Self::SYMBOL => {
diff --git a/crates/agent_ui/src/inline_prompt_editor.rs b/crates/agent_ui/src/inline_prompt_editor.rs
index d268c2f21154ee0dae5eeab1e35a900f6b773d69..b6517a54339df71659805ff38718e94be7192fa8 100644
--- a/crates/agent_ui/src/inline_prompt_editor.rs
+++ b/crates/agent_ui/src/inline_prompt_editor.rs
@@ -1,29 +1,18 @@
-use crate::agent_model_selector::AgentModelSelector;
-use crate::buffer_codegen::BufferCodegen;
-use crate::context_picker::{ContextPicker, ContextPickerCompletionProvider};
-use crate::context_strip::{ContextStrip, ContextStripEvent, SuggestContextKind};
-use crate::message_editor::{ContextCreasesAddon, extract_message_creases, insert_message_creases};
-use crate::terminal_codegen::TerminalCodegen;
-use crate::{CycleNextInlineAssist, CyclePreviousInlineAssist, ModelUsageContext};
-use crate::{RemoveAllContext, ToggleContextPicker};
 use agent::{
     context_store::ContextStore,
     thread_store::{TextThreadStore, ThreadStore},
 };
-use client::ErrorExt;
 use collections::VecDeque;
-use db::kvp::Dismissable;
 use editor::actions::Paste;
 use editor::display_map::EditorMargins;
 use editor::{
     ContextMenuOptions, Editor, EditorElement, EditorEvent, EditorMode, EditorStyle, MultiBuffer,
     actions::{MoveDown, MoveUp},
 };
-use feature_flags::{FeatureFlagAppExt as _, ZedProFeatureFlag};
 use fs::Fs;
 use gpui::{
-    AnyElement, App, ClickEvent, Context, CursorStyle, Entity, EventEmitter, FocusHandle,
-    Focusable, FontWeight, Subscription, TextStyle, WeakEntity, Window, anchored, deferred, point,
+    AnyElement, App, Context, CursorStyle, Entity, EventEmitter, FocusHandle, Focusable,
+    Subscription, TextStyle, WeakEntity, Window,
 };
 use language_model::{LanguageModel, LanguageModelRegistry};
 use parking_lot::Mutex;
@@ -33,12 +22,19 @@ use std::rc::Rc;
 use std::sync::Arc;
 use theme::ThemeSettings;
 use ui::utils::WithRemSize;
-use ui::{
-    CheckboxWithLabel, IconButtonShape, KeyBinding, Popover, PopoverMenuHandle, Tooltip, prelude::*,
-};
+use ui::{IconButtonShape, KeyBinding, PopoverMenuHandle, Tooltip, prelude::*};
 use workspace::Workspace;
 use zed_actions::agent::ToggleModelSelector;
 
+use crate::agent_model_selector::AgentModelSelector;
+use crate::buffer_codegen::BufferCodegen;
+use crate::context_picker::{ContextPicker, ContextPickerCompletionProvider};
+use crate::context_strip::{ContextStrip, ContextStripEvent, SuggestContextKind};
+use crate::message_editor::{ContextCreasesAddon, extract_message_creases, insert_message_creases};
+use crate::terminal_codegen::TerminalCodegen;
+use crate::{CycleNextInlineAssist, CyclePreviousInlineAssist, ModelUsageContext};
+use crate::{RemoveAllContext, ToggleContextPicker};
+
 pub struct PromptEditor<T> {
     pub editor: Entity<Editor>,
     mode: PromptEditorMode,
@@ -144,47 +140,16 @@ impl<T: 'static> Render for PromptEditor<T> {
                                 };
 
                                 let error_message = SharedString::from(error.to_string());
-                                if error.error_code() == proto::ErrorCode::RateLimitExceeded
-                                    && cx.has_flag::<ZedProFeatureFlag>()
-                                {
-                                    el.child(
-                                        v_flex()
-                                            .child(
-                                                IconButton::new(
-                                                    "rate-limit-error",
-                                                    IconName::XCircle,
-                                                )
-                                                .toggle_state(self.show_rate_limit_notice)
-                                                .shape(IconButtonShape::Square)
-                                                .icon_size(IconSize::Small)
-                                                .on_click(
-                                                    cx.listener(Self::toggle_rate_limit_notice),
-                                                ),
-                                            )
-                                            .children(self.show_rate_limit_notice.then(|| {
-                                                deferred(
-                                                    anchored()
-                                                        .position_mode(
-                                                            gpui::AnchoredPositionMode::Local,
-                                                        )
-                                                        .position(point(px(0.), px(24.)))
-                                                        .anchor(gpui::Corner::TopLeft)
-                                                        .child(self.render_rate_limit_notice(cx)),
-                                                )
-                                            })),
-                                    )
-                                } else {
-                                    el.child(
-                                        div()
-                                            .id("error")
-                                            .tooltip(Tooltip::text(error_message))
-                                            .child(
-                                                Icon::new(IconName::XCircle)
-                                                    .size(IconSize::Small)
-                                                    .color(Color::Error),
-                                            ),
-                                    )
-                                }
+                                el.child(
+                                    div()
+                                        .id("error")
+                                        .tooltip(Tooltip::text(error_message))
+                                        .child(
+                                            Icon::new(IconName::XCircle)
+                                                .size(IconSize::Small)
+                                                .color(Color::Error),
+                                        ),
+                                )
                             }),
                     )
                     .child(
@@ -310,19 +275,6 @@ impl<T: 'static> PromptEditor<T> {
         crate::active_thread::attach_pasted_images_as_context(&self.context_store, cx);
     }
 
-    fn toggle_rate_limit_notice(
-        &mut self,
-        _: &ClickEvent,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        self.show_rate_limit_notice = !self.show_rate_limit_notice;
-        if self.show_rate_limit_notice {
-            window.focus(&self.editor.focus_handle(cx));
-        }
-        cx.notify();
-    }
-
     fn handle_prompt_editor_events(
         &mut self,
         _: &Entity<Editor>,
@@ -707,61 +659,6 @@ impl<T: 'static> PromptEditor<T> {
             .into_any_element()
     }
 
-    fn render_rate_limit_notice(&self, cx: &mut Context<Self>) -> impl IntoElement {
-        Popover::new().child(
-            v_flex()
-                .occlude()
-                .p_2()
-                .child(
-                    Label::new("Out of Tokens")
-                        .size(LabelSize::Small)
-                        .weight(FontWeight::BOLD),
-                )
-                .child(Label::new(
-                    "Try Zed Pro for higher limits, a wider range of models, and more.",
-                ))
-                .child(
-                    h_flex()
-                        .justify_between()
-                        .child(CheckboxWithLabel::new(
-                            "dont-show-again",
-                            Label::new("Don't show again"),
-                            if RateLimitNotice::dismissed() {
-                                ui::ToggleState::Selected
-                            } else {
-                                ui::ToggleState::Unselected
-                            },
-                            |selection, _, cx| {
-                                let is_dismissed = match selection {
-                                    ui::ToggleState::Unselected => false,
-                                    ui::ToggleState::Indeterminate => return,
-                                    ui::ToggleState::Selected => true,
-                                };
-
-                                RateLimitNotice::set_dismissed(is_dismissed, cx);
-                            },
-                        ))
-                        .child(
-                            h_flex()
-                                .gap_2()
-                                .child(
-                                    Button::new("dismiss", "Dismiss")
-                                        .style(ButtonStyle::Transparent)
-                                        .on_click(cx.listener(Self::toggle_rate_limit_notice)),
-                                )
-                                .child(Button::new("more-info", "More Info").on_click(
-                                    |_event, window, cx| {
-                                        window.dispatch_action(
-                                            Box::new(zed_actions::OpenAccountSettings),
-                                            cx,
-                                        )
-                                    },
-                                )),
-                        ),
-                ),
-        )
-    }
-
     fn render_editor(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> AnyElement {
         let colors = cx.theme().colors();
 
@@ -978,15 +875,7 @@ impl PromptEditor<BufferCodegen> {
                 self.editor
                     .update(cx, |editor, _| editor.set_read_only(false));
             }
-            CodegenStatus::Error(error) => {
-                if cx.has_flag::<ZedProFeatureFlag>()
-                    && error.error_code() == proto::ErrorCode::RateLimitExceeded
-                    && !RateLimitNotice::dismissed()
-                {
-                    self.show_rate_limit_notice = true;
-                    cx.notify();
-                }
-
+            CodegenStatus::Error(_error) => {
                 self.edited_since_done = false;
                 self.editor
                     .update(cx, |editor, _| editor.set_read_only(false));
@@ -1189,12 +1078,6 @@ impl PromptEditor<TerminalCodegen> {
     }
 }
 
-struct RateLimitNotice;
-
-impl Dismissable for RateLimitNotice {
-    const KEY: &'static str = "dismissed-rate-limit-notice";
-}
-
 pub enum CodegenStatus {
     Idle,
     Pending,
diff --git a/crates/agent_ui/src/language_model_selector.rs b/crates/agent_ui/src/language_model_selector.rs
index 3633e533da97b2b80e5c8d62c271da7121d3582b..eb5a734b4ca57c2b79ac0dd004e42fc59c195fed 100644
--- a/crates/agent_ui/src/language_model_selector.rs
+++ b/crates/agent_ui/src/language_model_selector.rs
@@ -1,8 +1,6 @@
 use std::{cmp::Reverse, sync::Arc};
 
-use cloud_llm_client::Plan;
 use collections::{HashSet, IndexMap};
-use feature_flags::ZedProFeatureFlag;
 use fuzzy::{StringMatch, StringMatchCandidate, match_strings};
 use gpui::{Action, AnyElement, App, BackgroundExecutor, DismissEvent, Subscription, Task};
 use language_model::{
@@ -13,8 +11,6 @@ use ordered_float::OrderedFloat;
 use picker::{Picker, PickerDelegate};
 use ui::{ListItem, ListItemSpacing, prelude::*};
 
-const TRY_ZED_PRO_URL: &str = "https://zed.dev/pro";
-
 type OnModelChanged = Arc<dyn Fn(Arc<dyn LanguageModel>, &mut App) + 'static>;
 type GetActiveModel = Arc<dyn Fn(&App) -> Option<ConfiguredModel> + 'static>;
 
@@ -531,13 +527,9 @@ impl PickerDelegate for LanguageModelPickerDelegate {
 
     fn render_footer(
         &self,
-        _: &mut Window,
+        _window: &mut Window,
         cx: &mut Context<Picker<Self>>,
     ) -> Option<gpui::AnyElement> {
-        use feature_flags::FeatureFlagAppExt;
-
-        let plan = Plan::ZedPro;
-
         Some(
             h_flex()
                 .w_full()
@@ -546,28 +538,6 @@ impl PickerDelegate for LanguageModelPickerDelegate {
                 .p_1()
                 .gap_4()
                 .justify_between()
-                .when(cx.has_flag::<ZedProFeatureFlag>(), |this| {
-                    this.child(match plan {
-                        Plan::ZedPro => Button::new("zed-pro", "Zed Pro")
-                            .icon(IconName::ZedAssistant)
-                            .icon_size(IconSize::Small)
-                            .icon_color(Color::Muted)
-                            .icon_position(IconPosition::Start)
-                            .on_click(|_, window, cx| {
-                                window
-                                    .dispatch_action(Box::new(zed_actions::OpenAccountSettings), cx)
-                            }),
-                        Plan::ZedFree | Plan::ZedProTrial => Button::new(
-                            "try-pro",
-                            if plan == Plan::ZedProTrial {
-                                "Upgrade to Pro"
-                            } else {
-                                "Try Pro"
-                            },
-                        )
-                        .on_click(|_, _, cx| cx.open_url(TRY_ZED_PRO_URL)),
-                    })
-                })
                 .child(
                     Button::new("configure", "Configure")
                         .icon(IconName::Settings)
diff --git a/crates/agent_ui/src/message_editor.rs b/crates/agent_ui/src/message_editor.rs
index 45e7529ec21c576354a556bdc27112da4d57e085..6f0ad2767a46fb23b40e0116fd9cf85f06c28aca 100644
--- a/crates/agent_ui/src/message_editor.rs
+++ b/crates/agent_ui/src/message_editor.rs
@@ -125,6 +125,7 @@ pub(crate) fn create_editor(
             cx,
         );
         editor.set_placeholder_text("Message the agent – @ to include context", cx);
+        editor.disable_word_completions();
         editor.set_show_indent_guides(false, cx);
         editor.set_soft_wrap();
         editor.set_use_modal_editing(true);
diff --git a/crates/agent_ui/src/profile_selector.rs b/crates/agent_ui/src/profile_selector.rs
index f0f53b96b24c1d4f97fe94ecf155ebb7b73c6fa9..6ae4a73598a8e0e48509dda7a9bdd5e4fa2ea0ff 100644
--- a/crates/agent_ui/src/profile_selector.rs
+++ b/crates/agent_ui/src/profile_selector.rs
@@ -6,8 +6,8 @@ use gpui::{Action, Entity, FocusHandle, Subscription, prelude::*};
 use settings::{Settings as _, SettingsStore, update_settings_file};
 use std::sync::Arc;
 use ui::{
-    ContextMenu, ContextMenuEntry, DocumentationSide, PopoverMenu, PopoverMenuHandle, Tooltip,
-    prelude::*,
+    ContextMenu, ContextMenuEntry, DocumentationSide, PopoverMenu, PopoverMenuHandle, TintColor,
+    Tooltip, prelude::*,
 };
 
 /// Trait for types that can provide and manage agent profiles
@@ -170,7 +170,8 @@ impl Render for ProfileSelector {
                 .icon(IconName::ChevronDown)
                 .icon_size(IconSize::XSmall)
                 .icon_position(IconPosition::End)
-                .icon_color(Color::Muted);
+                .icon_color(Color::Muted)
+                .selected_style(ButtonStyle::Tinted(TintColor::Accent));
 
             PopoverMenu::new("profile-selector")
                 .trigger_with_tooltip(trigger_button, {
@@ -195,6 +196,10 @@ impl Render for ProfileSelector {
                 .menu(move |window, cx| {
                     Some(this.update(cx, |this, cx| this.build_context_menu(window, cx)))
                 })
+                .offset(gpui::Point {
+                    x: px(0.0),
+                    y: px(-2.0),
+                })
                 .into_any_element()
         } else {
             Button::new("tools-not-supported-button", "Tools Unsupported")
diff --git a/crates/agent_ui/src/slash_command_settings.rs b/crates/agent_ui/src/slash_command_settings.rs
index c54a10ed49a77d395c4968e551b1cd30ad1c6e07..9580ffef0f317fbe726c57041fad4f0fa438e143 100644
--- a/crates/agent_ui/src/slash_command_settings.rs
+++ b/crates/agent_ui/src/slash_command_settings.rs
@@ -2,10 +2,11 @@ use anyhow::Result;
 use gpui::App;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 
 /// Settings for slash commands.
-#[derive(Deserialize, Serialize, Debug, Default, Clone, JsonSchema, SettingsUi)]
+#[derive(Deserialize, Serialize, Debug, Default, Clone, JsonSchema, SettingsUi, SettingsKey)]
+#[settings_key(key = "slash_commands")]
 pub struct SlashCommandSettings {
     /// Settings for the `/cargo-workspace` slash command.
     #[serde(default)]
@@ -21,8 +22,6 @@ pub struct CargoWorkspaceCommandSettings {
 }
 
 impl Settings for SlashCommandSettings {
-    const KEY: Option<&'static str> = Some("slash_commands");
-
     type FileContent = Self;
 
     fn load(sources: SettingsSources<Self::FileContent>, _cx: &mut App) -> Result<Self> {
diff --git a/crates/agent_ui/src/ui/end_trial_upsell.rs b/crates/agent_ui/src/ui/end_trial_upsell.rs
index 3a8a119800543ad033efd563d7896ccc80add373..55164aef716aa2d8d64195c69b765c6e429e8ce5 100644
--- a/crates/agent_ui/src/ui/end_trial_upsell.rs
+++ b/crates/agent_ui/src/ui/end_trial_upsell.rs
@@ -2,6 +2,7 @@ use std::sync::Arc;
 
 use ai_onboarding::{AgentPanelOnboardingCard, PlanDefinitions};
 use client::zed_urls;
+use feature_flags::{BillingV2FeatureFlag, FeatureFlagAppExt as _};
 use gpui::{AnyElement, App, IntoElement, RenderOnce, Window};
 use ui::{Divider, Tooltip, prelude::*};
 
@@ -18,8 +19,6 @@ impl EndTrialUpsell {
 
 impl RenderOnce for EndTrialUpsell {
     fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
-        let plan_definitions = PlanDefinitions;
-
         let pro_section = v_flex()
             .gap_1()
             .child(
@@ -33,7 +32,7 @@ impl RenderOnce for EndTrialUpsell {
                     )
                     .child(Divider::horizontal()),
             )
-            .child(plan_definitions.pro_plan(false))
+            .child(PlanDefinitions.pro_plan(cx.has_flag::<BillingV2FeatureFlag>(), false))
             .child(
                 Button::new("cta-button", "Upgrade to Zed Pro")
                     .full_width()
@@ -64,7 +63,7 @@ impl RenderOnce for EndTrialUpsell {
                     )
                     .child(Divider::horizontal()),
             )
-            .child(plan_definitions.free_plan());
+            .child(PlanDefinitions.free_plan(cx.has_flag::<BillingV2FeatureFlag>()));
 
         AgentPanelOnboardingCard::new()
             .child(Headline::new("Your Zed Pro Trial has expired"))
diff --git a/crates/agent_ui/src/ui/preview/usage_callouts.rs b/crates/agent_ui/src/ui/preview/usage_callouts.rs
index d4d037b9765e5bd20bbcd547f5cc906285d26711..7c080f075a5101b7082b550d5ffbd9fa8ec92525 100644
--- a/crates/agent_ui/src/ui/preview/usage_callouts.rs
+++ b/crates/agent_ui/src/ui/preview/usage_callouts.rs
@@ -45,13 +45,13 @@ impl RenderOnce for UsageCallout {
                     "Upgrade",
                     zed_urls::account_url(cx),
                 ),
-                Plan::ZedProTrial => (
+                Plan::ZedProTrial | Plan::ZedProTrialV2 => (
                     "Out of trial prompts",
                     "Upgrade to Zed Pro to continue, or switch to API key.".to_string(),
                     "Upgrade",
                     zed_urls::account_url(cx),
                 ),
-                Plan::ZedPro => (
+                Plan::ZedPro | Plan::ZedProV2 => (
                     "Out of included prompts",
                     "Enable usage-based billing to continue.".to_string(),
                     "Manage",
diff --git a/crates/ai_onboarding/Cargo.toml b/crates/ai_onboarding/Cargo.toml
index 95a45b1a6fbe103f02532d33c21af707f2f51d45..cf3e6e9cd66eff0ce412436d4dc1d2b4b01c0041 100644
--- a/crates/ai_onboarding/Cargo.toml
+++ b/crates/ai_onboarding/Cargo.toml
@@ -18,6 +18,7 @@ default = []
 client.workspace = true
 cloud_llm_client.workspace = true
 component.workspace = true
+feature_flags.workspace = true
 gpui.workspace = true
 language_model.workspace = true
 serde.workspace = true
diff --git a/crates/ai_onboarding/src/ai_onboarding.rs b/crates/ai_onboarding/src/ai_onboarding.rs
index 6d8ac6472563ac0abd79d59f44b36a924eee1757..60b8fa89ffe5b1c4779083ff0b5641dd9bf9bcc8 100644
--- a/crates/ai_onboarding/src/ai_onboarding.rs
+++ b/crates/ai_onboarding/src/ai_onboarding.rs
@@ -18,6 +18,7 @@ pub use young_account_banner::YoungAccountBanner;
 use std::sync::Arc;
 
 use client::{Client, UserStore, zed_urls};
+use feature_flags::{BillingV2FeatureFlag, FeatureFlagAppExt as _};
 use gpui::{AnyElement, Entity, IntoElement, ParentElement};
 use ui::{Divider, RegisterComponent, Tooltip, prelude::*};
 
@@ -84,9 +85,8 @@ impl ZedAiOnboarding {
         self
     }
 
-    fn render_sign_in_disclaimer(&self, _cx: &mut App) -> AnyElement {
+    fn render_sign_in_disclaimer(&self, cx: &mut App) -> AnyElement {
         let signing_in = matches!(self.sign_in_status, SignInStatus::SigningIn);
-        let plan_definitions = PlanDefinitions;
 
         v_flex()
             .gap_1()
@@ -96,7 +96,7 @@ impl ZedAiOnboarding {
                     .color(Color::Muted)
                     .mb_2(),
             )
-            .child(plan_definitions.pro_plan(false))
+            .child(PlanDefinitions.pro_plan(cx.has_flag::<BillingV2FeatureFlag>(), false))
             .child(
                 Button::new("sign_in", "Try Zed Pro for Free")
                     .disabled(signing_in)
@@ -114,16 +114,13 @@ impl ZedAiOnboarding {
     }
 
     fn render_free_plan_state(&self, cx: &mut App) -> AnyElement {
-        let young_account_banner = YoungAccountBanner;
-        let plan_definitions = PlanDefinitions;
-
         if self.account_too_young {
             v_flex()
                 .relative()
                 .max_w_full()
                 .gap_1()
                 .child(Headline::new("Welcome to Zed AI"))
-                .child(young_account_banner)
+                .child(YoungAccountBanner)
                 .child(
                     v_flex()
                         .mt_2()
@@ -139,7 +136,9 @@ impl ZedAiOnboarding {
                                 )
                                 .child(Divider::horizontal()),
                         )
-                        .child(plan_definitions.pro_plan(true))
+                        .child(
+                            PlanDefinitions.pro_plan(cx.has_flag::<BillingV2FeatureFlag>(), true),
+                        )
                         .child(
                             Button::new("pro", "Get Started")
                                 .full_width()
@@ -182,7 +181,7 @@ impl ZedAiOnboarding {
                                 )
                                 .child(Divider::horizontal()),
                         )
-                        .child(plan_definitions.free_plan()),
+                        .child(PlanDefinitions.free_plan(cx.has_flag::<BillingV2FeatureFlag>())),
                 )
                 .when_some(
                     self.dismiss_onboarding.as_ref(),
@@ -220,7 +219,9 @@ impl ZedAiOnboarding {
                                 )
                                 .child(Divider::horizontal()),
                         )
-                        .child(plan_definitions.pro_trial(true))
+                        .child(
+                            PlanDefinitions.pro_trial(cx.has_flag::<BillingV2FeatureFlag>(), true),
+                        )
                         .child(
                             Button::new("pro", "Start Free Trial")
                                 .full_width()
@@ -238,9 +239,7 @@ impl ZedAiOnboarding {
         }
     }
 
-    fn render_trial_state(&self, _cx: &mut App) -> AnyElement {
-        let plan_definitions = PlanDefinitions;
-
+    fn render_trial_state(&self, is_v2: bool, _cx: &mut App) -> AnyElement {
         v_flex()
             .relative()
             .gap_1()
@@ -250,7 +249,7 @@ impl ZedAiOnboarding {
                     .color(Color::Muted)
                     .mb_2(),
             )
-            .child(plan_definitions.pro_trial(false))
+            .child(PlanDefinitions.pro_trial(is_v2, false))
             .when_some(
                 self.dismiss_onboarding.as_ref(),
                 |this, dismiss_callback| {
@@ -274,9 +273,7 @@ impl ZedAiOnboarding {
             .into_any_element()
     }
 
-    fn render_pro_plan_state(&self, _cx: &mut App) -> AnyElement {
-        let plan_definitions = PlanDefinitions;
-
+    fn render_pro_plan_state(&self, is_v2: bool, _cx: &mut App) -> AnyElement {
         v_flex()
             .gap_1()
             .child(Headline::new("Welcome to Zed Pro"))
@@ -285,7 +282,7 @@ impl ZedAiOnboarding {
                     .color(Color::Muted)
                     .mb_2(),
             )
-            .child(plan_definitions.pro_plan(false))
+            .child(PlanDefinitions.pro_plan(is_v2, false))
             .when_some(
                 self.dismiss_onboarding.as_ref(),
                 |this, dismiss_callback| {
@@ -315,8 +312,10 @@ impl RenderOnce for ZedAiOnboarding {
         if matches!(self.sign_in_status, SignInStatus::SignedIn) {
             match self.plan {
                 None | Some(Plan::ZedFree) => self.render_free_plan_state(cx),
-                Some(Plan::ZedProTrial) => self.render_trial_state(cx),
-                Some(Plan::ZedPro) => self.render_pro_plan_state(cx),
+                Some(Plan::ZedProTrial) => self.render_trial_state(false, cx),
+                Some(Plan::ZedProTrialV2) => self.render_trial_state(true, cx),
+                Some(Plan::ZedPro) => self.render_pro_plan_state(false, cx),
+                Some(Plan::ZedProV2) => self.render_pro_plan_state(true, cx),
             }
         } else {
             self.render_sign_in_disclaimer(cx)
diff --git a/crates/ai_onboarding/src/ai_upsell_card.rs b/crates/ai_onboarding/src/ai_upsell_card.rs
index d6e7a0bbad321148495b37292c3d17f4321c0a6e..6a797d84379ca5d108c7b69806c7432ead3beeff 100644
--- a/crates/ai_onboarding/src/ai_upsell_card.rs
+++ b/crates/ai_onboarding/src/ai_upsell_card.rs
@@ -2,6 +2,7 @@ use std::sync::Arc;
 
 use client::{Client, UserStore, zed_urls};
 use cloud_llm_client::Plan;
+use feature_flags::{BillingV2FeatureFlag, FeatureFlagAppExt};
 use gpui::{AnyElement, App, Entity, IntoElement, RenderOnce, Window};
 use ui::{CommonAnimationExt, Divider, Vector, VectorName, prelude::*};
 
@@ -49,9 +50,6 @@ impl AiUpsellCard {
 
 impl RenderOnce for AiUpsellCard {
     fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
-        let plan_definitions = PlanDefinitions;
-        let young_account_banner = YoungAccountBanner;
-
         let pro_section = v_flex()
             .flex_grow()
             .w_full()
@@ -67,7 +65,7 @@ impl RenderOnce for AiUpsellCard {
                     )
                     .child(Divider::horizontal()),
             )
-            .child(plan_definitions.pro_plan(false));
+            .child(PlanDefinitions.pro_plan(cx.has_flag::<BillingV2FeatureFlag>(), false));
 
         let free_section = v_flex()
             .flex_grow()
@@ -84,7 +82,7 @@ impl RenderOnce for AiUpsellCard {
                     )
                     .child(Divider::horizontal()),
             )
-            .child(plan_definitions.free_plan());
+            .child(PlanDefinitions.free_plan(cx.has_flag::<BillingV2FeatureFlag>()));
 
         let grid_bg = h_flex()
             .absolute()
@@ -173,7 +171,7 @@ impl RenderOnce for AiUpsellCard {
                     .child(Label::new("Try Zed AI").size(LabelSize::Large))
                     .map(|this| {
                         if self.account_too_young {
-                            this.child(young_account_banner).child(
+                            this.child(YoungAccountBanner).child(
                                 v_flex()
                                     .mt_2()
                                     .gap_1()
@@ -188,7 +186,10 @@ impl RenderOnce for AiUpsellCard {
                                             )
                                             .child(Divider::horizontal()),
                                     )
-                                    .child(plan_definitions.pro_plan(true))
+                                    .child(
+                                        PlanDefinitions
+                                            .pro_plan(cx.has_flag::<BillingV2FeatureFlag>(), true),
+                                    )
                                     .child(
                                         Button::new("pro", "Get Started")
                                             .full_width()
@@ -235,7 +236,7 @@ impl RenderOnce for AiUpsellCard {
                             )
                         }
                     }),
-                Some(Plan::ZedProTrial) => card
+                Some(plan @ Plan::ZedProTrial | plan @ Plan::ZedProTrialV2) => card
                     .child(pro_trial_stamp)
                     .child(Label::new("You're in the Zed Pro Trial").size(LabelSize::Large))
                     .child(
@@ -243,8 +244,8 @@ impl RenderOnce for AiUpsellCard {
                             .color(Color::Muted)
                             .mb_2(),
                     )
-                    .child(plan_definitions.pro_trial(false)),
-                Some(Plan::ZedPro) => card
+                    .child(PlanDefinitions.pro_trial(plan == Plan::ZedProTrialV2, false)),
+                Some(plan @ Plan::ZedPro | plan @ Plan::ZedProV2) => card
                     .child(certified_user_stamp)
                     .child(Label::new("You're in the Zed Pro plan").size(LabelSize::Large))
                     .child(
@@ -252,7 +253,7 @@ impl RenderOnce for AiUpsellCard {
                             .color(Color::Muted)
                             .mb_2(),
                     )
-                    .child(plan_definitions.pro_plan(false)),
+                    .child(PlanDefinitions.pro_plan(plan == Plan::ZedProV2, false)),
             },
             // Signed Out State
             _ => card
diff --git a/crates/ai_onboarding/src/plan_definitions.rs b/crates/ai_onboarding/src/plan_definitions.rs
index 8d66f6c3563c482b2356e081b5786219f5bf1de3..dce67d421006ce918018923b86dbe22012efef01 100644
--- a/crates/ai_onboarding/src/plan_definitions.rs
+++ b/crates/ai_onboarding/src/plan_definitions.rs
@@ -7,13 +7,13 @@ pub struct PlanDefinitions;
 impl PlanDefinitions {
     pub const AI_DESCRIPTION: &'static str = "Zed offers a complete agentic experience, with robust editing and reviewing features to collaborate with AI.";
 
-    pub fn free_plan(&self) -> impl IntoElement {
+    pub fn free_plan(&self, _is_v2: bool) -> impl IntoElement {
         List::new()
             .child(ListBulletItem::new("50 prompts with Claude models"))
             .child(ListBulletItem::new("2,000 accepted edit predictions"))
     }
 
-    pub fn pro_trial(&self, period: bool) -> impl IntoElement {
+    pub fn pro_trial(&self, _is_v2: bool, period: bool) -> impl IntoElement {
         List::new()
             .child(ListBulletItem::new("150 prompts with Claude models"))
             .child(ListBulletItem::new(
@@ -26,7 +26,7 @@ impl PlanDefinitions {
             })
     }
 
-    pub fn pro_plan(&self, price: bool) -> impl IntoElement {
+    pub fn pro_plan(&self, _is_v2: bool, price: bool) -> impl IntoElement {
         List::new()
             .child(ListBulletItem::new("500 prompts with Claude models"))
             .child(ListBulletItem::new(
diff --git a/crates/assistant_context/src/assistant_context_tests.rs b/crates/assistant_context/src/assistant_context_tests.rs
index 61d748cbddb0858dda2f181ea6c943426393e087..8b182685cfeb4e3ae1b9df8c532b8f0c5ad91235 100644
--- a/crates/assistant_context/src/assistant_context_tests.rs
+++ b/crates/assistant_context/src/assistant_context_tests.rs
@@ -764,7 +764,7 @@ async fn test_random_context_collaboration(cx: &mut TestAppContext, mut rng: Std
     let network = Arc::new(Mutex::new(Network::new(rng.clone())));
     let mut contexts = Vec::new();
 
-    let num_peers = rng.gen_range(min_peers..=max_peers);
+    let num_peers = rng.random_range(min_peers..=max_peers);
     let context_id = ContextId::new();
     let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
     for i in 0..num_peers {
@@ -806,10 +806,10 @@ async fn test_random_context_collaboration(cx: &mut TestAppContext, mut rng: Std
         || !network.lock().is_idle()
         || network.lock().contains_disconnected_peers()
     {
-        let context_index = rng.gen_range(0..contexts.len());
+        let context_index = rng.random_range(0..contexts.len());
         let context = &contexts[context_index];
 
-        match rng.gen_range(0..100) {
+        match rng.random_range(0..100) {
             0..=29 if mutation_count > 0 => {
                 log::info!("Context {}: edit buffer", context_index);
                 context.update(cx, |context, cx| {
@@ -874,10 +874,10 @@ async fn test_random_context_collaboration(cx: &mut TestAppContext, mut rng: Std
                         merge_same_roles: true,
                     })];
 
-                    let num_sections = rng.gen_range(0..=3);
+                    let num_sections = rng.random_range(0..=3);
                     let mut section_start = 0;
                     for _ in 0..num_sections {
-                        let mut section_end = rng.gen_range(section_start..=output_text.len());
+                        let mut section_end = rng.random_range(section_start..=output_text.len());
                         while !output_text.is_char_boundary(section_end) {
                             section_end += 1;
                         }
@@ -924,7 +924,7 @@ async fn test_random_context_collaboration(cx: &mut TestAppContext, mut rng: Std
             75..=84 if mutation_count > 0 => {
                 context.update(cx, |context, cx| {
                     if let Some(message) = context.messages(cx).choose(&mut rng) {
-                        let new_status = match rng.gen_range(0..3) {
+                        let new_status = match rng.random_range(0..3) {
                             0 => MessageStatus::Done,
                             1 => MessageStatus::Pending,
                             _ => MessageStatus::Error(SharedString::from("Random error")),
@@ -971,7 +971,7 @@ async fn test_random_context_collaboration(cx: &mut TestAppContext, mut rng: Std
 
                     network.lock().broadcast(replica_id, ops_to_send);
                     context.update(cx, |context, cx| context.apply_ops(ops_to_receive, cx));
-                } else if rng.gen_bool(0.1) && replica_id != 0 {
+                } else if rng.random_bool(0.1) && replica_id != 0 {
                     log::info!("Context {}: disconnecting", context_index);
                     network.lock().disconnect_peer(replica_id);
                 } else if network.lock().has_unreceived(replica_id) {
diff --git a/crates/assistant_tools/src/edit_agent.rs b/crates/assistant_tools/src/edit_agent.rs
index 665ece2baaeed0dac32e5c0153ec1d79fef47f12..29ac53e2a606d63873f515aff25326debf0486f1 100644
--- a/crates/assistant_tools/src/edit_agent.rs
+++ b/crates/assistant_tools/src/edit_agent.rs
@@ -1315,17 +1315,17 @@ mod tests {
 
     #[gpui::test(iterations = 100)]
     async fn test_random_indents(mut rng: StdRng) {
-        let len = rng.gen_range(1..=100);
+        let len = rng.random_range(1..=100);
         let new_text = util::RandomCharIter::new(&mut rng)
             .with_simple_text()
             .take(len)
             .collect::<String>();
         let new_text = new_text
             .split('\n')
-            .map(|line| format!("{}{}", " ".repeat(rng.gen_range(0..=8)), line))
+            .map(|line| format!("{}{}", " ".repeat(rng.random_range(0..=8)), line))
             .collect::<Vec<_>>()
             .join("\n");
-        let delta = IndentDelta::Spaces(rng.gen_range(-4..=4));
+        let delta = IndentDelta::Spaces(rng.random_range(-4i8..=4i8) as isize);
 
         let chunks = to_random_chunks(&mut rng, &new_text);
         let new_text_chunks = stream::iter(chunks.iter().enumerate().map(|(index, chunk)| {
@@ -1357,7 +1357,7 @@ mod tests {
     }
 
     fn to_random_chunks(rng: &mut StdRng, input: &str) -> Vec<String> {
-        let chunk_count = rng.gen_range(1..=cmp::min(input.len(), 50));
+        let chunk_count = rng.random_range(1..=cmp::min(input.len(), 50));
         let mut chunk_indices = (0..input.len()).choose_multiple(rng, chunk_count);
         chunk_indices.sort();
         chunk_indices.push(input.len());
diff --git a/crates/assistant_tools/src/edit_agent/create_file_parser.rs b/crates/assistant_tools/src/edit_agent/create_file_parser.rs
index 0aad9ecb87c1426486b531ac4291913cd0d74092..5126f9c6b1fe4ee5cc600ae93b7300b7af09451f 100644
--- a/crates/assistant_tools/src/edit_agent/create_file_parser.rs
+++ b/crates/assistant_tools/src/edit_agent/create_file_parser.rs
@@ -204,7 +204,7 @@ mod tests {
     }
 
     fn parse_random_chunks(input: &str, parser: &mut CreateFileParser, rng: &mut StdRng) -> String {
-        let chunk_count = rng.gen_range(1..=cmp::min(input.len(), 50));
+        let chunk_count = rng.random_range(1..=cmp::min(input.len(), 50));
         let mut chunk_indices = (0..input.len()).choose_multiple(rng, chunk_count);
         chunk_indices.sort();
         chunk_indices.push(input.len());
diff --git a/crates/assistant_tools/src/edit_agent/edit_parser.rs b/crates/assistant_tools/src/edit_agent/edit_parser.rs
index db58c2bf3685030abfa6cfdd506c068c6643dce8..8411171ba4ea491d2603014a0715ce471b34e36f 100644
--- a/crates/assistant_tools/src/edit_agent/edit_parser.rs
+++ b/crates/assistant_tools/src/edit_agent/edit_parser.rs
@@ -996,7 +996,7 @@ mod tests {
     }
 
     fn parse_random_chunks(input: &str, parser: &mut EditParser, rng: &mut StdRng) -> Vec<Edit> {
-        let chunk_count = rng.gen_range(1..=cmp::min(input.len(), 50));
+        let chunk_count = rng.random_range(1..=cmp::min(input.len(), 50));
         let mut chunk_indices = (0..input.len()).choose_multiple(rng, chunk_count);
         chunk_indices.sort();
         chunk_indices.push(input.len());
diff --git a/crates/assistant_tools/src/edit_agent/evals.rs b/crates/assistant_tools/src/edit_agent/evals.rs
index 4f182b31481c5d855b59f4398e104d0eea05bc74..e78d43f56b2f13f90b83968dadd5ff79e1a96658 100644
--- a/crates/assistant_tools/src/edit_agent/evals.rs
+++ b/crates/assistant_tools/src/edit_agent/evals.rs
@@ -1399,7 +1399,7 @@ fn eval(
 }
 
 fn run_eval(eval: EvalInput, tx: mpsc::Sender<Result<EvalOutput>>) {
-    let dispatcher = gpui::TestDispatcher::new(StdRng::from_entropy());
+    let dispatcher = gpui::TestDispatcher::new(StdRng::from_os_rng());
     let mut cx = TestAppContext::build(dispatcher, None);
     let output = cx.executor().block_test(async {
         let test = EditAgentTest::new(&mut cx).await;
@@ -1707,7 +1707,7 @@ async fn retry_on_rate_limit<R>(mut request: impl AsyncFnMut() -> Result<R>) ->
         };
 
         if let Some(retry_after) = retry_delay {
-            let jitter = retry_after.mul_f64(rand::thread_rng().gen_range(0.0..1.0));
+            let jitter = retry_after.mul_f64(rand::rng().random_range(0.0..1.0));
             eprintln!("Attempt #{attempt}: Retry after {retry_after:?} + jitter of {jitter:?}");
             Timer::after(retry_after + jitter).await;
         } else {
diff --git a/crates/assistant_tools/src/edit_agent/streaming_fuzzy_matcher.rs b/crates/assistant_tools/src/edit_agent/streaming_fuzzy_matcher.rs
index 33b37679f0a345ef070942057b307bd377012d05..386b8204400a157b37b2f356829fa27df3abca92 100644
--- a/crates/assistant_tools/src/edit_agent/streaming_fuzzy_matcher.rs
+++ b/crates/assistant_tools/src/edit_agent/streaming_fuzzy_matcher.rs
@@ -771,7 +771,7 @@ mod tests {
     }
 
     fn to_random_chunks(rng: &mut StdRng, input: &str) -> Vec<String> {
-        let chunk_count = rng.gen_range(1..=cmp::min(input.len(), 50));
+        let chunk_count = rng.random_range(1..=cmp::min(input.len(), 50));
         let mut chunk_indices = (0..input.len()).choose_multiple(rng, chunk_count);
         chunk_indices.sort();
         chunk_indices.push(input.len());
diff --git a/crates/audio/src/audio_settings.rs b/crates/audio/src/audio_settings.rs
index d30d950273f2138f3bd54c573513373574f1ce43..168519030bcbd4a422965580ddbe01121934278d 100644
--- a/crates/audio/src/audio_settings.rs
+++ b/crates/audio/src/audio_settings.rs
@@ -2,9 +2,9 @@ use anyhow::Result;
 use gpui::App;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi)]
 pub struct AudioSettings {
     /// Opt into the new audio system.
     #[serde(rename = "experimental.rodio_audio", default)]
@@ -12,8 +12,9 @@ pub struct AudioSettings {
 }
 
 /// Configuration of audio in Zed.
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi, SettingsKey)]
 #[serde(default)]
+#[settings_key(key = "audio")]
 pub struct AudioSettingsContent {
     /// Whether to use the experimental audio system
     #[serde(rename = "experimental.rodio_audio", default)]
@@ -21,8 +22,6 @@ pub struct AudioSettingsContent {
 }
 
 impl Settings for AudioSettings {
-    const KEY: Option<&'static str> = Some("audio");
-
     type FileContent = AudioSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _cx: &mut App) -> Result<Self> {
diff --git a/crates/auto_update/src/auto_update.rs b/crates/auto_update/src/auto_update.rs
index f0ae3fdb1cfef667a9f737aa6545a42046a9d322..f5d4533a9ee042e62752f26b989bc75561c534ae 100644
--- a/crates/auto_update/src/auto_update.rs
+++ b/crates/auto_update/src/auto_update.rs
@@ -10,7 +10,7 @@ use paths::remote_servers_dir;
 use release_channel::{AppCommitSha, ReleaseChannel};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsStore, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsStore, SettingsUi};
 use smol::{fs, io::AsyncReadExt};
 use smol::{fs::File, process::Command};
 use std::{
@@ -118,13 +118,12 @@ struct AutoUpdateSetting(bool);
 /// Whether or not to automatically check for updates.
 ///
 /// Default: true
-#[derive(Clone, Copy, Default, JsonSchema, Deserialize, Serialize, SettingsUi)]
+#[derive(Clone, Copy, Default, JsonSchema, Deserialize, Serialize, SettingsUi, SettingsKey)]
 #[serde(transparent)]
+#[settings_key(key = "auto_update")]
 struct AutoUpdateSettingContent(bool);
 
 impl Settings for AutoUpdateSetting {
-    const KEY: Option<&'static str> = Some("auto_update");
-
     type FileContent = AutoUpdateSettingContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
diff --git a/crates/auto_update_ui/src/auto_update_ui.rs b/crates/auto_update_ui/src/auto_update_ui.rs
index 7063dffd6d84a13f8aa4d08ca91a6ce85826417d..efac14968ea48d93ae35089d239916de1f0a5253 100644
--- a/crates/auto_update_ui/src/auto_update_ui.rs
+++ b/crates/auto_update_ui/src/auto_update_ui.rs
@@ -1,5 +1,4 @@
 use auto_update::AutoUpdater;
-use client::proto::UpdateNotification;
 use editor::{Editor, MultiBuffer};
 use gpui::{App, Context, DismissEvent, Entity, Window, actions, prelude::*};
 use http_client::HttpClient;
@@ -88,10 +87,7 @@ fn view_release_notes_locally(
                         .update_in(cx, |workspace, window, cx| {
                             let project = workspace.project().clone();
                             let buffer = project.update(cx, |project, cx| {
-                                let buffer = project.create_local_buffer("", markdown, cx);
-                                project
-                                    .mark_buffer_as_non_searchable(buffer.read(cx).remote_id(), cx);
-                                buffer
+                                project.create_local_buffer("", markdown, false, cx)
                             });
                             buffer.update(cx, |buffer, cx| {
                                 buffer.edit([(0..0, body.release_notes)], None, cx)
@@ -141,6 +137,8 @@ pub fn notify_if_app_was_updated(cx: &mut App) {
         return;
     }
 
+    struct UpdateNotification;
+
     let should_show_notification = updater.read(cx).should_show_update_notification(cx);
     cx.spawn(async move |cx| {
         let should_show_notification = should_show_notification.await?;
diff --git a/crates/buffer_diff/src/buffer_diff.rs b/crates/buffer_diff/src/buffer_diff.rs
index b20dad4ebbcc5990bd0a6a165375ca62481e609f..22ee20e0db2810610dc2e7a4cae86dca90681337 100644
--- a/crates/buffer_diff/src/buffer_diff.rs
+++ b/crates/buffer_diff/src/buffer_diff.rs
@@ -2044,10 +2044,10 @@ mod tests {
     #[gpui::test(iterations = 100)]
     async fn test_staging_and_unstaging_hunks(cx: &mut TestAppContext, mut rng: StdRng) {
         fn gen_line(rng: &mut StdRng) -> String {
-            if rng.gen_bool(0.2) {
+            if rng.random_bool(0.2) {
                 "\n".to_owned()
             } else {
-                let c = rng.gen_range('A'..='Z');
+                let c = rng.random_range('A'..='Z');
                 format!("{c}{c}{c}\n")
             }
         }
@@ -2066,7 +2066,7 @@ mod tests {
                 old_lines.into_iter()
             };
             let mut result = String::new();
-            let unchanged_count = rng.gen_range(0..=old_lines.len());
+            let unchanged_count = rng.random_range(0..=old_lines.len());
             result +=
                 &old_lines
                     .by_ref()
@@ -2076,14 +2076,14 @@ mod tests {
                         s
                     });
             while old_lines.len() > 0 {
-                let deleted_count = rng.gen_range(0..=old_lines.len());
+                let deleted_count = rng.random_range(0..=old_lines.len());
                 let _advance = old_lines
                     .by_ref()
                     .take(deleted_count)
                     .map(|line| line.len() + 1)
                     .sum::<usize>();
                 let minimum_added = if deleted_count == 0 { 1 } else { 0 };
-                let added_count = rng.gen_range(minimum_added..=5);
+                let added_count = rng.random_range(minimum_added..=5);
                 let addition = (0..added_count).map(|_| gen_line(rng)).collect::<String>();
                 result += &addition;
 
@@ -2092,7 +2092,8 @@ mod tests {
                     if blank_lines == old_lines.len() {
                         break;
                     };
-                    let unchanged_count = rng.gen_range((blank_lines + 1).max(1)..=old_lines.len());
+                    let unchanged_count =
+                        rng.random_range((blank_lines + 1).max(1)..=old_lines.len());
                     result += &old_lines.by_ref().take(unchanged_count).fold(
                         String::new(),
                         |mut s, line| {
@@ -2149,7 +2150,7 @@ mod tests {
             )
         });
         let working_copy = working_copy.read_with(cx, |working_copy, _| working_copy.snapshot());
-        let mut index_text = if rng.r#gen() {
+        let mut index_text = if rng.random() {
             Rope::from(head_text.as_str())
         } else {
             working_copy.as_rope().clone()
@@ -2165,7 +2166,7 @@ mod tests {
         }
 
         for _ in 0..operations {
-            let i = rng.gen_range(0..hunks.len());
+            let i = rng.random_range(0..hunks.len());
             let hunk = &mut hunks[i];
             let hunk_to_change = hunk.clone();
             let stage = match hunk.secondary_status {
diff --git a/crates/call/src/call_settings.rs b/crates/call/src/call_settings.rs
index 7b0838e3a96185c1e4c33b8116fbd6a41b35f3dc..b0677e3c3bcb5112fdd9ad2abc4bf188b225aeac 100644
--- a/crates/call/src/call_settings.rs
+++ b/crates/call/src/call_settings.rs
@@ -2,7 +2,7 @@ use anyhow::Result;
 use gpui::App;
 use schemars::JsonSchema;
 use serde_derive::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 
 #[derive(Deserialize, Debug)]
 pub struct CallSettings {
@@ -11,7 +11,8 @@ pub struct CallSettings {
 }
 
 /// Configuration of voice calls in Zed.
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi, SettingsKey)]
+#[settings_key(key = "calls")]
 pub struct CallSettingsContent {
     /// Whether the microphone should be muted when joining a channel or a call.
     ///
@@ -25,8 +26,6 @@ pub struct CallSettingsContent {
 }
 
 impl Settings for CallSettings {
-    const KEY: Option<&'static str> = Some("calls");
-
     type FileContent = CallSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
diff --git a/crates/channel/Cargo.toml b/crates/channel/Cargo.toml
index 962847f3f1cf21f361b6e2f1b9299c0c66992b3e..ab6e1dfc2b8dd0f89c4e6cd03e5ee66840003d6a 100644
--- a/crates/channel/Cargo.toml
+++ b/crates/channel/Cargo.toml
@@ -25,11 +25,9 @@ gpui.workspace = true
 language.workspace = true
 log.workspace = true
 postage.workspace = true
-rand.workspace = true
 release_channel.workspace = true
 rpc.workspace = true
 settings.workspace = true
-sum_tree.workspace = true
 text.workspace = true
 time.workspace = true
 util.workspace = true
diff --git a/crates/channel/src/channel.rs b/crates/channel/src/channel.rs
index 63865c574ecc36da27e18f02ccb8c44138cef3ba..6cc5a0e8815a4f24f41b3677622f8c200a4f59d9 100644
--- a/crates/channel/src/channel.rs
+++ b/crates/channel/src/channel.rs
@@ -1,5 +1,4 @@
 mod channel_buffer;
-mod channel_chat;
 mod channel_store;
 
 use client::{Client, UserStore};
@@ -7,10 +6,6 @@ use gpui::{App, Entity};
 use std::sync::Arc;
 
 pub use channel_buffer::{ACKNOWLEDGE_DEBOUNCE_INTERVAL, ChannelBuffer, ChannelBufferEvent};
-pub use channel_chat::{
-    ChannelChat, ChannelChatEvent, ChannelMessage, ChannelMessageId, MessageParams,
-    mentions_to_proto,
-};
 pub use channel_store::{Channel, ChannelEvent, ChannelMembership, ChannelStore};
 
 #[cfg(test)]
@@ -19,5 +14,4 @@ mod channel_store_tests;
 pub fn init(client: &Arc<Client>, user_store: Entity<UserStore>, cx: &mut App) {
     channel_store::init(client, user_store, cx);
     channel_buffer::init(&client.clone().into());
-    channel_chat::init(&client.clone().into());
 }
diff --git a/crates/channel/src/channel_chat.rs b/crates/channel/src/channel_chat.rs
deleted file mode 100644
index baf23ac39f983c018da2f291bec7879913f12a58..0000000000000000000000000000000000000000
--- a/crates/channel/src/channel_chat.rs
+++ /dev/null
@@ -1,861 +0,0 @@
-use crate::{Channel, ChannelStore};
-use anyhow::{Context as _, Result};
-use client::{
-    ChannelId, Client, Subscription, TypedEnvelope, UserId, proto,
-    user::{User, UserStore},
-};
-use collections::HashSet;
-use futures::lock::Mutex;
-use gpui::{App, AppContext as _, AsyncApp, Context, Entity, EventEmitter, Task, WeakEntity};
-use rand::prelude::*;
-use rpc::AnyProtoClient;
-use std::{
-    ops::{ControlFlow, Range},
-    sync::Arc,
-};
-use sum_tree::{Bias, Dimensions, SumTree};
-use time::OffsetDateTime;
-use util::{ResultExt as _, TryFutureExt, post_inc};
-
-pub struct ChannelChat {
-    pub channel_id: ChannelId,
-    messages: SumTree<ChannelMessage>,
-    acknowledged_message_ids: HashSet<u64>,
-    channel_store: Entity<ChannelStore>,
-    loaded_all_messages: bool,
-    last_acknowledged_id: Option<u64>,
-    next_pending_message_id: usize,
-    first_loaded_message_id: Option<u64>,
-    user_store: Entity<UserStore>,
-    rpc: Arc<Client>,
-    outgoing_messages_lock: Arc<Mutex<()>>,
-    rng: StdRng,
-    _subscription: Subscription,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub struct MessageParams {
-    pub text: String,
-    pub mentions: Vec<(Range<usize>, UserId)>,
-    pub reply_to_message_id: Option<u64>,
-}
-
-#[derive(Clone, Debug)]
-pub struct ChannelMessage {
-    pub id: ChannelMessageId,
-    pub body: String,
-    pub timestamp: OffsetDateTime,
-    pub sender: Arc<User>,
-    pub nonce: u128,
-    pub mentions: Vec<(Range<usize>, UserId)>,
-    pub reply_to_message_id: Option<u64>,
-    pub edited_at: Option<OffsetDateTime>,
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum ChannelMessageId {
-    Saved(u64),
-    Pending(usize),
-}
-
-impl From<ChannelMessageId> for Option<u64> {
-    fn from(val: ChannelMessageId) -> Self {
-        match val {
-            ChannelMessageId::Saved(id) => Some(id),
-            ChannelMessageId::Pending(_) => None,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct ChannelMessageSummary {
-    max_id: ChannelMessageId,
-    count: usize,
-}
-
-#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
-struct Count(usize);
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum ChannelChatEvent {
-    MessagesUpdated {
-        old_range: Range<usize>,
-        new_count: usize,
-    },
-    UpdateMessage {
-        message_id: ChannelMessageId,
-        message_ix: usize,
-    },
-    NewMessage {
-        channel_id: ChannelId,
-        message_id: u64,
-    },
-}
-
-impl EventEmitter<ChannelChatEvent> for ChannelChat {}
-pub fn init(client: &AnyProtoClient) {
-    client.add_entity_message_handler(ChannelChat::handle_message_sent);
-    client.add_entity_message_handler(ChannelChat::handle_message_removed);
-    client.add_entity_message_handler(ChannelChat::handle_message_updated);
-}
-
-impl ChannelChat {
-    pub async fn new(
-        channel: Arc<Channel>,
-        channel_store: Entity<ChannelStore>,
-        user_store: Entity<UserStore>,
-        client: Arc<Client>,
-        cx: &mut AsyncApp,
-    ) -> Result<Entity<Self>> {
-        let channel_id = channel.id;
-        let subscription = client.subscribe_to_entity(channel_id.0).unwrap();
-
-        let response = client
-            .request(proto::JoinChannelChat {
-                channel_id: channel_id.0,
-            })
-            .await?;
-
-        let handle = cx.new(|cx| {
-            cx.on_release(Self::release).detach();
-            Self {
-                channel_id: channel.id,
-                user_store: user_store.clone(),
-                channel_store,
-                rpc: client.clone(),
-                outgoing_messages_lock: Default::default(),
-                messages: Default::default(),
-                acknowledged_message_ids: Default::default(),
-                loaded_all_messages: false,
-                next_pending_message_id: 0,
-                last_acknowledged_id: None,
-                rng: StdRng::from_entropy(),
-                first_loaded_message_id: None,
-                _subscription: subscription.set_entity(&cx.entity(), &cx.to_async()),
-            }
-        })?;
-        Self::handle_loaded_messages(
-            handle.downgrade(),
-            user_store,
-            client,
-            response.messages,
-            response.done,
-            cx,
-        )
-        .await?;
-        Ok(handle)
-    }
-
-    fn release(&mut self, _: &mut App) {
-        self.rpc
-            .send(proto::LeaveChannelChat {
-                channel_id: self.channel_id.0,
-            })
-            .log_err();
-    }
-
-    pub fn channel(&self, cx: &App) -> Option<Arc<Channel>> {
-        self.channel_store
-            .read(cx)
-            .channel_for_id(self.channel_id)
-            .cloned()
-    }
-
-    pub fn client(&self) -> &Arc<Client> {
-        &self.rpc
-    }
-
-    pub fn send_message(
-        &mut self,
-        message: MessageParams,
-        cx: &mut Context<Self>,
-    ) -> Result<Task<Result<u64>>> {
-        anyhow::ensure!(
-            !message.text.trim().is_empty(),
-            "message body can't be empty"
-        );
-
-        let current_user = self
-            .user_store
-            .read(cx)
-            .current_user()
-            .context("current_user is not present")?;
-
-        let channel_id = self.channel_id;
-        let pending_id = ChannelMessageId::Pending(post_inc(&mut self.next_pending_message_id));
-        let nonce = self.rng.r#gen();
-        self.insert_messages(
-            SumTree::from_item(
-                ChannelMessage {
-                    id: pending_id,
-                    body: message.text.clone(),
-                    sender: current_user,
-                    timestamp: OffsetDateTime::now_utc(),
-                    mentions: message.mentions.clone(),
-                    nonce,
-                    reply_to_message_id: message.reply_to_message_id,
-                    edited_at: None,
-                },
-                &(),
-            ),
-            cx,
-        );
-        let user_store = self.user_store.clone();
-        let rpc = self.rpc.clone();
-        let outgoing_messages_lock = self.outgoing_messages_lock.clone();
-
-        // todo - handle messages that fail to send (e.g. >1024 chars)
-        Ok(cx.spawn(async move |this, cx| {
-            let outgoing_message_guard = outgoing_messages_lock.lock().await;
-            let request = rpc.request(proto::SendChannelMessage {
-                channel_id: channel_id.0,
-                body: message.text,
-                nonce: Some(nonce.into()),
-                mentions: mentions_to_proto(&message.mentions),
-                reply_to_message_id: message.reply_to_message_id,
-            });
-            let response = request.await?;
-            drop(outgoing_message_guard);
-            let response = response.message.context("invalid message")?;
-            let id = response.id;
-            let message = ChannelMessage::from_proto(response, &user_store, cx).await?;
-            this.update(cx, |this, cx| {
-                this.insert_messages(SumTree::from_item(message, &()), cx);
-                if this.first_loaded_message_id.is_none() {
-                    this.first_loaded_message_id = Some(id);
-                }
-            })?;
-            Ok(id)
-        }))
-    }
-
-    pub fn remove_message(&mut self, id: u64, cx: &mut Context<Self>) -> Task<Result<()>> {
-        let response = self.rpc.request(proto::RemoveChannelMessage {
-            channel_id: self.channel_id.0,
-            message_id: id,
-        });
-        cx.spawn(async move |this, cx| {
-            response.await?;
-            this.update(cx, |this, cx| {
-                this.message_removed(id, cx);
-            })?;
-            Ok(())
-        })
-    }
-
-    pub fn update_message(
-        &mut self,
-        id: u64,
-        message: MessageParams,
-        cx: &mut Context<Self>,
-    ) -> Result<Task<Result<()>>> {
-        self.message_update(
-            ChannelMessageId::Saved(id),
-            message.text.clone(),
-            message.mentions.clone(),
-            Some(OffsetDateTime::now_utc()),
-            cx,
-        );
-
-        let nonce: u128 = self.rng.r#gen();
-
-        let request = self.rpc.request(proto::UpdateChannelMessage {
-            channel_id: self.channel_id.0,
-            message_id: id,
-            body: message.text,
-            nonce: Some(nonce.into()),
-            mentions: mentions_to_proto(&message.mentions),
-        });
-        Ok(cx.spawn(async move |_, _| {
-            request.await?;
-            Ok(())
-        }))
-    }
-
-    pub fn load_more_messages(&mut self, cx: &mut Context<Self>) -> Option<Task<Option<()>>> {
-        if self.loaded_all_messages {
-            return None;
-        }
-
-        let rpc = self.rpc.clone();
-        let user_store = self.user_store.clone();
-        let channel_id = self.channel_id;
-        let before_message_id = self.first_loaded_message_id()?;
-        Some(cx.spawn(async move |this, cx| {
-            async move {
-                let response = rpc
-                    .request(proto::GetChannelMessages {
-                        channel_id: channel_id.0,
-                        before_message_id,
-                    })
-                    .await?;
-                Self::handle_loaded_messages(
-                    this,
-                    user_store,
-                    rpc,
-                    response.messages,
-                    response.done,
-                    cx,
-                )
-                .await?;
-
-                anyhow::Ok(())
-            }
-            .log_err()
-            .await
-        }))
-    }
-
-    pub fn first_loaded_message_id(&mut self) -> Option<u64> {
-        self.first_loaded_message_id
-    }
-
-    /// Load a message by its id, if it's already stored locally.
-    pub fn find_loaded_message(&self, id: u64) -> Option<&ChannelMessage> {
-        self.messages.iter().find(|message| match message.id {
-            ChannelMessageId::Saved(message_id) => message_id == id,
-            ChannelMessageId::Pending(_) => false,
-        })
-    }
-
-    /// Load all of the chat messages since a certain message id.
-    ///
-    /// For now, we always maintain a suffix of the channel's messages.
-    pub async fn load_history_since_message(
-        chat: Entity<Self>,
-        message_id: u64,
-        mut cx: AsyncApp,
-    ) -> Option<usize> {
-        loop {
-            let step = chat
-                .update(&mut cx, |chat, cx| {
-                    if let Some(first_id) = chat.first_loaded_message_id()
-                        && first_id <= message_id
-                    {
-                        let mut cursor = chat
-                            .messages
-                            .cursor::<Dimensions<ChannelMessageId, Count>>(&());
-                        let message_id = ChannelMessageId::Saved(message_id);
-                        cursor.seek(&message_id, Bias::Left);
-                        return ControlFlow::Break(
-                            if cursor
-                                .item()
-                                .is_some_and(|message| message.id == message_id)
-                            {
-                                Some(cursor.start().1.0)
-                            } else {
-                                None
-                            },
-                        );
-                    }
-                    ControlFlow::Continue(chat.load_more_messages(cx))
-                })
-                .log_err()?;
-            match step {
-                ControlFlow::Break(ix) => return ix,
-                ControlFlow::Continue(task) => task?.await?,
-            }
-        }
-    }
-
-    pub fn acknowledge_last_message(&mut self, cx: &mut Context<Self>) {
-        if let ChannelMessageId::Saved(latest_message_id) = self.messages.summary().max_id
-            && self
-                .last_acknowledged_id
-                .is_none_or(|acknowledged_id| acknowledged_id < latest_message_id)
-        {
-            self.rpc
-                .send(proto::AckChannelMessage {
-                    channel_id: self.channel_id.0,
-                    message_id: latest_message_id,
-                })
-                .ok();
-            self.last_acknowledged_id = Some(latest_message_id);
-            self.channel_store.update(cx, |store, cx| {
-                store.acknowledge_message_id(self.channel_id, latest_message_id, cx);
-            });
-        }
-    }
-
-    async fn handle_loaded_messages(
-        this: WeakEntity<Self>,
-        user_store: Entity<UserStore>,
-        rpc: Arc<Client>,
-        proto_messages: Vec<proto::ChannelMessage>,
-        loaded_all_messages: bool,
-        cx: &mut AsyncApp,
-    ) -> Result<()> {
-        let loaded_messages = messages_from_proto(proto_messages, &user_store, cx).await?;
-
-        let first_loaded_message_id = loaded_messages.first().map(|m| m.id);
-        let loaded_message_ids = this.read_with(cx, |this, _| {
-            let mut loaded_message_ids: HashSet<u64> = HashSet::default();
-            for message in loaded_messages.iter() {
-                if let Some(saved_message_id) = message.id.into() {
-                    loaded_message_ids.insert(saved_message_id);
-                }
-            }
-            for message in this.messages.iter() {
-                if let Some(saved_message_id) = message.id.into() {
-                    loaded_message_ids.insert(saved_message_id);
-                }
-            }
-            loaded_message_ids
-        })?;
-
-        let missing_ancestors = loaded_messages
-            .iter()
-            .filter_map(|message| {
-                if let Some(ancestor_id) = message.reply_to_message_id
-                    && !loaded_message_ids.contains(&ancestor_id)
-                {
-                    return Some(ancestor_id);
-                }
-                None
-            })
-            .collect::<Vec<_>>();
-
-        let loaded_ancestors = if missing_ancestors.is_empty() {
-            None
-        } else {
-            let response = rpc
-                .request(proto::GetChannelMessagesById {
-                    message_ids: missing_ancestors,
-                })
-                .await?;
-            Some(messages_from_proto(response.messages, &user_store, cx).await?)
-        };
-        this.update(cx, |this, cx| {
-            this.first_loaded_message_id = first_loaded_message_id.and_then(|msg_id| msg_id.into());
-            this.loaded_all_messages = loaded_all_messages;
-            this.insert_messages(loaded_messages, cx);
-            if let Some(loaded_ancestors) = loaded_ancestors {
-                this.insert_messages(loaded_ancestors, cx);
-            }
-        })?;
-
-        Ok(())
-    }
-
-    pub fn rejoin(&mut self, cx: &mut Context<Self>) {
-        let user_store = self.user_store.clone();
-        let rpc = self.rpc.clone();
-        let channel_id = self.channel_id;
-        cx.spawn(async move |this, cx| {
-            async move {
-                let response = rpc
-                    .request(proto::JoinChannelChat {
-                        channel_id: channel_id.0,
-                    })
-                    .await?;
-                Self::handle_loaded_messages(
-                    this.clone(),
-                    user_store.clone(),
-                    rpc.clone(),
-                    response.messages,
-                    response.done,
-                    cx,
-                )
-                .await?;
-
-                let pending_messages = this.read_with(cx, |this, _| {
-                    this.pending_messages().cloned().collect::<Vec<_>>()
-                })?;
-
-                for pending_message in pending_messages {
-                    let request = rpc.request(proto::SendChannelMessage {
-                        channel_id: channel_id.0,
-                        body: pending_message.body,
-                        mentions: mentions_to_proto(&pending_message.mentions),
-                        nonce: Some(pending_message.nonce.into()),
-                        reply_to_message_id: pending_message.reply_to_message_id,
-                    });
-                    let response = request.await?;
-                    let message = ChannelMessage::from_proto(
-                        response.message.context("invalid message")?,
-                        &user_store,
-                        cx,
-                    )
-                    .await?;
-                    this.update(cx, |this, cx| {
-                        this.insert_messages(SumTree::from_item(message, &()), cx);
-                    })?;
-                }
-
-                anyhow::Ok(())
-            }
-            .log_err()
-            .await
-        })
-        .detach();
-    }
-
-    pub fn message_count(&self) -> usize {
-        self.messages.summary().count
-    }
-
-    pub fn messages(&self) -> &SumTree<ChannelMessage> {
-        &self.messages
-    }
-
-    pub fn message(&self, ix: usize) -> &ChannelMessage {
-        let mut cursor = self.messages.cursor::<Count>(&());
-        cursor.seek(&Count(ix), Bias::Right);
-        cursor.item().unwrap()
-    }
-
-    pub fn acknowledge_message(&mut self, id: u64) {
-        if self.acknowledged_message_ids.insert(id) {
-            self.rpc
-                .send(proto::AckChannelMessage {
-                    channel_id: self.channel_id.0,
-                    message_id: id,
-                })
-                .ok();
-        }
-    }
-
-    pub fn messages_in_range(&self, range: Range<usize>) -> impl Iterator<Item = &ChannelMessage> {
-        let mut cursor = self.messages.cursor::<Count>(&());
-        cursor.seek(&Count(range.start), Bias::Right);
-        cursor.take(range.len())
-    }
-
-    pub fn pending_messages(&self) -> impl Iterator<Item = &ChannelMessage> {
-        let mut cursor = self.messages.cursor::<ChannelMessageId>(&());
-        cursor.seek(&ChannelMessageId::Pending(0), Bias::Left);
-        cursor
-    }
-
-    async fn handle_message_sent(
-        this: Entity<Self>,
-        message: TypedEnvelope<proto::ChannelMessageSent>,
-        mut cx: AsyncApp,
-    ) -> Result<()> {
-        let user_store = this.read_with(&cx, |this, _| this.user_store.clone())?;
-        let message = message.payload.message.context("empty message")?;
-        let message_id = message.id;
-
-        let message = ChannelMessage::from_proto(message, &user_store, &mut cx).await?;
-        this.update(&mut cx, |this, cx| {
-            this.insert_messages(SumTree::from_item(message, &()), cx);
-            cx.emit(ChannelChatEvent::NewMessage {
-                channel_id: this.channel_id,
-                message_id,
-            })
-        })?;
-
-        Ok(())
-    }
-
-    async fn handle_message_removed(
-        this: Entity<Self>,
-        message: TypedEnvelope<proto::RemoveChannelMessage>,
-        mut cx: AsyncApp,
-    ) -> Result<()> {
-        this.update(&mut cx, |this, cx| {
-            this.message_removed(message.payload.message_id, cx)
-        })?;
-        Ok(())
-    }
-
-    async fn handle_message_updated(
-        this: Entity<Self>,
-        message: TypedEnvelope<proto::ChannelMessageUpdate>,
-        mut cx: AsyncApp,
-    ) -> Result<()> {
-        let user_store = this.read_with(&cx, |this, _| this.user_store.clone())?;
-        let message = message.payload.message.context("empty message")?;
-
-        let message = ChannelMessage::from_proto(message, &user_store, &mut cx).await?;
-
-        this.update(&mut cx, |this, cx| {
-            this.message_update(
-                message.id,
-                message.body,
-                message.mentions,
-                message.edited_at,
-                cx,
-            )
-        })?;
-        Ok(())
-    }
-
-    fn insert_messages(&mut self, messages: SumTree<ChannelMessage>, cx: &mut Context<Self>) {
-        if let Some((first_message, last_message)) = messages.first().zip(messages.last()) {
-            let nonces = messages
-                .cursor::<()>(&())
-                .map(|m| m.nonce)
-                .collect::<HashSet<_>>();
-
-            let mut old_cursor = self
-                .messages
-                .cursor::<Dimensions<ChannelMessageId, Count>>(&());
-            let mut new_messages = old_cursor.slice(&first_message.id, Bias::Left);
-            let start_ix = old_cursor.start().1.0;
-            let removed_messages = old_cursor.slice(&last_message.id, Bias::Right);
-            let removed_count = removed_messages.summary().count;
-            let new_count = messages.summary().count;
-            let end_ix = start_ix + removed_count;
-
-            new_messages.append(messages, &());
-
-            let mut ranges = Vec::<Range<usize>>::new();
-            if new_messages.last().unwrap().is_pending() {
-                new_messages.append(old_cursor.suffix(), &());
-            } else {
-                new_messages.append(
-                    old_cursor.slice(&ChannelMessageId::Pending(0), Bias::Left),
-                    &(),
-                );
-
-                while let Some(message) = old_cursor.item() {
-                    let message_ix = old_cursor.start().1.0;
-                    if nonces.contains(&message.nonce) {
-                        if ranges.last().is_some_and(|r| r.end == message_ix) {
-                            ranges.last_mut().unwrap().end += 1;
-                        } else {
-                            ranges.push(message_ix..message_ix + 1);
-                        }
-                    } else {
-                        new_messages.push(message.clone(), &());
-                    }
-                    old_cursor.next();
-                }
-            }
-
-            drop(old_cursor);
-            self.messages = new_messages;
-
-            for range in ranges.into_iter().rev() {
-                cx.emit(ChannelChatEvent::MessagesUpdated {
-                    old_range: range,
-                    new_count: 0,
-                });
-            }
-            cx.emit(ChannelChatEvent::MessagesUpdated {
-                old_range: start_ix..end_ix,
-                new_count,
-            });
-
-            cx.notify();
-        }
-    }
-
-    fn message_removed(&mut self, id: u64, cx: &mut Context<Self>) {
-        let mut cursor = self.messages.cursor::<ChannelMessageId>(&());
-        let mut messages = cursor.slice(&ChannelMessageId::Saved(id), Bias::Left);
-        if let Some(item) = cursor.item()
-            && item.id == ChannelMessageId::Saved(id)
-        {
-            let deleted_message_ix = messages.summary().count;
-            cursor.next();
-            messages.append(cursor.suffix(), &());
-            drop(cursor);
-            self.messages = messages;
-
-            // If the message that was deleted was the last acknowledged message,
-            // replace the acknowledged message with an earlier one.
-            self.channel_store.update(cx, |store, _| {
-                let summary = self.messages.summary();
-                if summary.count == 0 {
-                    store.set_acknowledged_message_id(self.channel_id, None);
-                } else if deleted_message_ix == summary.count
-                    && let ChannelMessageId::Saved(id) = summary.max_id
-                {
-                    store.set_acknowledged_message_id(self.channel_id, Some(id));
-                }
-            });
-
-            cx.emit(ChannelChatEvent::MessagesUpdated {
-                old_range: deleted_message_ix..deleted_message_ix + 1,
-                new_count: 0,
-            });
-        }
-    }
-
-    fn message_update(
-        &mut self,
-        id: ChannelMessageId,
-        body: String,
-        mentions: Vec<(Range<usize>, u64)>,
-        edited_at: Option<OffsetDateTime>,
-        cx: &mut Context<Self>,
-    ) {
-        let mut cursor = self.messages.cursor::<ChannelMessageId>(&());
-        let mut messages = cursor.slice(&id, Bias::Left);
-        let ix = messages.summary().count;
-
-        if let Some(mut message_to_update) = cursor.item().cloned() {
-            message_to_update.body = body;
-            message_to_update.mentions = mentions;
-            message_to_update.edited_at = edited_at;
-            messages.push(message_to_update, &());
-            cursor.next();
-        }
-
-        messages.append(cursor.suffix(), &());
-        drop(cursor);
-        self.messages = messages;
-
-        cx.emit(ChannelChatEvent::UpdateMessage {
-            message_ix: ix,
-            message_id: id,
-        });
-
-        cx.notify();
-    }
-}
-
-async fn messages_from_proto(
-    proto_messages: Vec<proto::ChannelMessage>,
-    user_store: &Entity<UserStore>,
-    cx: &mut AsyncApp,
-) -> Result<SumTree<ChannelMessage>> {
-    let messages = ChannelMessage::from_proto_vec(proto_messages, user_store, cx).await?;
-    let mut result = SumTree::default();
-    result.extend(messages, &());
-    Ok(result)
-}
-
-impl ChannelMessage {
-    pub async fn from_proto(
-        message: proto::ChannelMessage,
-        user_store: &Entity<UserStore>,
-        cx: &mut AsyncApp,
-    ) -> Result<Self> {
-        let sender = user_store
-            .update(cx, |user_store, cx| {
-                user_store.get_user(message.sender_id, cx)
-            })?
-            .await?;
-
-        let edited_at = message.edited_at.and_then(|t| -> Option<OffsetDateTime> {
-            if let Ok(a) = OffsetDateTime::from_unix_timestamp(t as i64) {
-                return Some(a);
-            }
-
-            None
-        });
-
-        Ok(ChannelMessage {
-            id: ChannelMessageId::Saved(message.id),
-            body: message.body,
-            mentions: message
-                .mentions
-                .into_iter()
-                .filter_map(|mention| {
-                    let range = mention.range?;
-                    Some((range.start as usize..range.end as usize, mention.user_id))
-                })
-                .collect(),
-            timestamp: OffsetDateTime::from_unix_timestamp(message.timestamp as i64)?,
-            sender,
-            nonce: message.nonce.context("nonce is required")?.into(),
-            reply_to_message_id: message.reply_to_message_id,
-            edited_at,
-        })
-    }
-
-    pub fn is_pending(&self) -> bool {
-        matches!(self.id, ChannelMessageId::Pending(_))
-    }
-
-    pub async fn from_proto_vec(
-        proto_messages: Vec<proto::ChannelMessage>,
-        user_store: &Entity<UserStore>,
-        cx: &mut AsyncApp,
-    ) -> Result<Vec<Self>> {
-        let unique_user_ids = proto_messages
-            .iter()
-            .map(|m| m.sender_id)
-            .collect::<HashSet<_>>()
-            .into_iter()
-            .collect();
-        user_store
-            .update(cx, |user_store, cx| {
-                user_store.get_users(unique_user_ids, cx)
-            })?
-            .await?;
-
-        let mut messages = Vec::with_capacity(proto_messages.len());
-        for message in proto_messages {
-            messages.push(ChannelMessage::from_proto(message, user_store, cx).await?);
-        }
-        Ok(messages)
-    }
-}
-
-pub fn mentions_to_proto(mentions: &[(Range<usize>, UserId)]) -> Vec<proto::ChatMention> {
-    mentions
-        .iter()
-        .map(|(range, user_id)| proto::ChatMention {
-            range: Some(proto::Range {
-                start: range.start as u64,
-                end: range.end as u64,
-            }),
-            user_id: *user_id,
-        })
-        .collect()
-}
-
-impl sum_tree::Item for ChannelMessage {
-    type Summary = ChannelMessageSummary;
-
-    fn summary(&self, _cx: &()) -> Self::Summary {
-        ChannelMessageSummary {
-            max_id: self.id,
-            count: 1,
-        }
-    }
-}
-
-impl Default for ChannelMessageId {
-    fn default() -> Self {
-        Self::Saved(0)
-    }
-}
-
-impl sum_tree::Summary for ChannelMessageSummary {
-    type Context = ();
-
-    fn zero(_cx: &Self::Context) -> Self {
-        Default::default()
-    }
-
-    fn add_summary(&mut self, summary: &Self, _: &()) {
-        self.max_id = summary.max_id;
-        self.count += summary.count;
-    }
-}
-
-impl<'a> sum_tree::Dimension<'a, ChannelMessageSummary> for ChannelMessageId {
-    fn zero(_cx: &()) -> Self {
-        Default::default()
-    }
-
-    fn add_summary(&mut self, summary: &'a ChannelMessageSummary, _: &()) {
-        debug_assert!(summary.max_id > *self);
-        *self = summary.max_id;
-    }
-}
-
-impl<'a> sum_tree::Dimension<'a, ChannelMessageSummary> for Count {
-    fn zero(_cx: &()) -> Self {
-        Default::default()
-    }
-
-    fn add_summary(&mut self, summary: &'a ChannelMessageSummary, _: &()) {
-        self.0 += summary.count;
-    }
-}
-
-impl<'a> From<&'a str> for MessageParams {
-    fn from(value: &'a str) -> Self {
-        Self {
-            text: value.into(),
-            mentions: Vec::new(),
-            reply_to_message_id: None,
-        }
-    }
-}
diff --git a/crates/channel/src/channel_store.rs b/crates/channel/src/channel_store.rs
index daa8a91c7c8952804c854b170d0bc2e1aa817631..e983d03e0d6758f681de9e4a3e6fd13dc7075b01 100644
--- a/crates/channel/src/channel_store.rs
+++ b/crates/channel/src/channel_store.rs
@@ -1,6 +1,6 @@
 mod channel_index;
 
-use crate::{ChannelMessage, channel_buffer::ChannelBuffer, channel_chat::ChannelChat};
+use crate::channel_buffer::ChannelBuffer;
 use anyhow::{Context as _, Result, anyhow};
 use channel_index::ChannelIndex;
 use client::{ChannelId, Client, ClientSettings, Subscription, User, UserId, UserStore};
@@ -41,7 +41,6 @@ pub struct ChannelStore {
     outgoing_invites: HashSet<(ChannelId, UserId)>,
     update_channels_tx: mpsc::UnboundedSender<proto::UpdateChannels>,
     opened_buffers: HashMap<ChannelId, OpenEntityHandle<ChannelBuffer>>,
-    opened_chats: HashMap<ChannelId, OpenEntityHandle<ChannelChat>>,
     client: Arc<Client>,
     did_subscribe: bool,
     channels_loaded: (watch::Sender<bool>, watch::Receiver<bool>),
@@ -63,10 +62,8 @@ pub struct Channel {
 
 #[derive(Default, Debug)]
 pub struct ChannelState {
-    latest_chat_message: Option<u64>,
     latest_notes_version: NotesVersion,
     observed_notes_version: NotesVersion,
-    observed_chat_message: Option<u64>,
     role: Option<ChannelRole>,
 }
 
@@ -196,7 +193,6 @@ impl ChannelStore {
             channel_participants: Default::default(),
             outgoing_invites: Default::default(),
             opened_buffers: Default::default(),
-            opened_chats: Default::default(),
             update_channels_tx,
             client,
             user_store,
@@ -362,89 +358,12 @@ impl ChannelStore {
         )
     }
 
-    pub fn fetch_channel_messages(
-        &self,
-        message_ids: Vec<u64>,
-        cx: &mut Context<Self>,
-    ) -> Task<Result<Vec<ChannelMessage>>> {
-        let request = if message_ids.is_empty() {
-            None
-        } else {
-            Some(
-                self.client
-                    .request(proto::GetChannelMessagesById { message_ids }),
-            )
-        };
-        cx.spawn(async move |this, cx| {
-            if let Some(request) = request {
-                let response = request.await?;
-                let this = this.upgrade().context("channel store dropped")?;
-                let user_store = this.read_with(cx, |this, _| this.user_store.clone())?;
-                ChannelMessage::from_proto_vec(response.messages, &user_store, cx).await
-            } else {
-                Ok(Vec::new())
-            }
-        })
-    }
-
     pub fn has_channel_buffer_changed(&self, channel_id: ChannelId) -> bool {
         self.channel_states
             .get(&channel_id)
             .is_some_and(|state| state.has_channel_buffer_changed())
     }
 
-    pub fn has_new_messages(&self, channel_id: ChannelId) -> bool {
-        self.channel_states
-            .get(&channel_id)
-            .is_some_and(|state| state.has_new_messages())
-    }
-
-    pub fn set_acknowledged_message_id(&mut self, channel_id: ChannelId, message_id: Option<u64>) {
-        if let Some(state) = self.channel_states.get_mut(&channel_id) {
-            state.latest_chat_message = message_id;
-        }
-    }
-
-    pub fn last_acknowledge_message_id(&self, channel_id: ChannelId) -> Option<u64> {
-        self.channel_states.get(&channel_id).and_then(|state| {
-            if let Some(last_message_id) = state.latest_chat_message
-                && state
-                    .last_acknowledged_message_id()
-                    .is_some_and(|id| id < last_message_id)
-            {
-                return state.last_acknowledged_message_id();
-            }
-
-            None
-        })
-    }
-
-    pub fn acknowledge_message_id(
-        &mut self,
-        channel_id: ChannelId,
-        message_id: u64,
-        cx: &mut Context<Self>,
-    ) {
-        self.channel_states
-            .entry(channel_id)
-            .or_default()
-            .acknowledge_message_id(message_id);
-        cx.notify();
-    }
-
-    pub fn update_latest_message_id(
-        &mut self,
-        channel_id: ChannelId,
-        message_id: u64,
-        cx: &mut Context<Self>,
-    ) {
-        self.channel_states
-            .entry(channel_id)
-            .or_default()
-            .update_latest_message_id(message_id);
-        cx.notify();
-    }
-
     pub fn acknowledge_notes_version(
         &mut self,
         channel_id: ChannelId,
@@ -473,23 +392,6 @@ impl ChannelStore {
         cx.notify()
     }
 
-    pub fn open_channel_chat(
-        &mut self,
-        channel_id: ChannelId,
-        cx: &mut Context<Self>,
-    ) -> Task<Result<Entity<ChannelChat>>> {
-        let client = self.client.clone();
-        let user_store = self.user_store.clone();
-        let this = cx.entity();
-        self.open_channel_resource(
-            channel_id,
-            "chat",
-            |this| &mut this.opened_chats,
-            async move |channel, cx| ChannelChat::new(channel, this, user_store, client, cx).await,
-            cx,
-        )
-    }
-
     /// Asynchronously open a given resource associated with a channel.
     ///
     /// Make sure that the resource is only opened once, even if this method
@@ -931,13 +833,6 @@ impl ChannelStore {
                     cx,
                 );
             }
-            for message_id in message.payload.observed_channel_message_id {
-                this.acknowledge_message_id(
-                    ChannelId(message_id.channel_id),
-                    message_id.message_id,
-                    cx,
-                );
-            }
             for membership in message.payload.channel_memberships {
                 if let Some(role) = ChannelRole::from_i32(membership.role) {
                     this.channel_states
@@ -957,16 +852,6 @@ impl ChannelStore {
         self.outgoing_invites.clear();
         self.disconnect_channel_buffers_task.take();
 
-        for chat in self.opened_chats.values() {
-            if let OpenEntityHandle::Open(chat) = chat
-                && let Some(chat) = chat.upgrade()
-            {
-                chat.update(cx, |chat, cx| {
-                    chat.rejoin(cx);
-                });
-            }
-        }
-
         let mut buffer_versions = Vec::new();
         for buffer in self.opened_buffers.values() {
             if let OpenEntityHandle::Open(buffer) = buffer
@@ -1094,7 +979,6 @@ impl ChannelStore {
         self.channel_participants.clear();
         self.outgoing_invites.clear();
         self.opened_buffers.clear();
-        self.opened_chats.clear();
         self.disconnect_channel_buffers_task = None;
         self.channel_states.clear();
     }
@@ -1131,7 +1015,6 @@ impl ChannelStore {
 
         let channels_changed = !payload.channels.is_empty()
             || !payload.delete_channels.is_empty()
-            || !payload.latest_channel_message_ids.is_empty()
             || !payload.latest_channel_buffer_versions.is_empty();
 
         if channels_changed {
@@ -1181,13 +1064,6 @@ impl ChannelStore {
                     .update_latest_notes_version(latest_buffer_version.epoch, &version)
             }
 
-            for latest_channel_message in payload.latest_channel_message_ids {
-                self.channel_states
-                    .entry(ChannelId(latest_channel_message.channel_id))
-                    .or_default()
-                    .update_latest_message_id(latest_channel_message.message_id);
-            }
-
             self.channels_loaded.0.try_send(true).log_err();
         }
 
@@ -1251,29 +1127,6 @@ impl ChannelState {
                     .changed_since(&self.observed_notes_version.version))
     }
 
-    fn has_new_messages(&self) -> bool {
-        let latest_message_id = self.latest_chat_message;
-        let observed_message_id = self.observed_chat_message;
-
-        latest_message_id.is_some_and(|latest_message_id| {
-            latest_message_id > observed_message_id.unwrap_or_default()
-        })
-    }
-
-    fn last_acknowledged_message_id(&self) -> Option<u64> {
-        self.observed_chat_message
-    }
-
-    fn acknowledge_message_id(&mut self, message_id: u64) {
-        let observed = self.observed_chat_message.get_or_insert(message_id);
-        *observed = (*observed).max(message_id);
-    }
-
-    fn update_latest_message_id(&mut self, message_id: u64) {
-        self.latest_chat_message =
-            Some(message_id.max(self.latest_chat_message.unwrap_or_default()));
-    }
-
     fn acknowledge_notes_version(&mut self, epoch: u64, version: &clock::Global) {
         if self.observed_notes_version.epoch == epoch {
             self.observed_notes_version.version.join(version);
diff --git a/crates/channel/src/channel_store_tests.rs b/crates/channel/src/channel_store_tests.rs
index 2a914330847053bc044da07e11642906b65a3159..fbdfe9f8b59f2b5e47720bb497c56b47c8abb77e 100644
--- a/crates/channel/src/channel_store_tests.rs
+++ b/crates/channel/src/channel_store_tests.rs
@@ -1,9 +1,7 @@
-use crate::channel_chat::ChannelChatEvent;
-
 use super::*;
-use client::{Client, UserStore, test::FakeServer};
+use client::{Client, UserStore};
 use clock::FakeSystemClock;
-use gpui::{App, AppContext as _, Entity, SemanticVersion, TestAppContext};
+use gpui::{App, AppContext as _, Entity, SemanticVersion};
 use http_client::FakeHttpClient;
 use rpc::proto::{self};
 use settings::SettingsStore;
@@ -235,201 +233,6 @@ fn test_dangling_channel_paths(cx: &mut App) {
     assert_channels(&channel_store, &[(0, "a".to_string())], cx);
 }
 
-#[gpui::test]
-async fn test_channel_messages(cx: &mut TestAppContext) {
-    let user_id = 5;
-    let channel_id = 5;
-    let channel_store = cx.update(init_test);
-    let client = channel_store.read_with(cx, |s, _| s.client());
-    let server = FakeServer::for_client(user_id, &client, cx).await;
-
-    // Get the available channels.
-    server.send(proto::UpdateChannels {
-        channels: vec![proto::Channel {
-            id: channel_id,
-            name: "the-channel".to_string(),
-            visibility: proto::ChannelVisibility::Members as i32,
-            parent_path: vec![],
-            channel_order: 1,
-        }],
-        ..Default::default()
-    });
-    cx.executor().run_until_parked();
-    cx.update(|cx| {
-        assert_channels(&channel_store, &[(0, "the-channel".to_string())], cx);
-    });
-
-    // Join a channel and populate its existing messages.
-    let channel = channel_store.update(cx, |store, cx| {
-        let channel_id = store.ordered_channels().next().unwrap().1.id;
-        store.open_channel_chat(channel_id, cx)
-    });
-    let join_channel = server.receive::<proto::JoinChannelChat>().await.unwrap();
-    server.respond(
-        join_channel.receipt(),
-        proto::JoinChannelChatResponse {
-            messages: vec![
-                proto::ChannelMessage {
-                    id: 10,
-                    body: "a".into(),
-                    timestamp: 1000,
-                    sender_id: 5,
-                    mentions: vec![],
-                    nonce: Some(1.into()),
-                    reply_to_message_id: None,
-                    edited_at: None,
-                },
-                proto::ChannelMessage {
-                    id: 11,
-                    body: "b".into(),
-                    timestamp: 1001,
-                    sender_id: 6,
-                    mentions: vec![],
-                    nonce: Some(2.into()),
-                    reply_to_message_id: None,
-                    edited_at: None,
-                },
-            ],
-            done: false,
-        },
-    );
-
-    cx.executor().start_waiting();
-
-    // Client requests all users for the received messages
-    let mut get_users = server.receive::<proto::GetUsers>().await.unwrap();
-    get_users.payload.user_ids.sort();
-    assert_eq!(get_users.payload.user_ids, vec![6]);
-    server.respond(
-        get_users.receipt(),
-        proto::UsersResponse {
-            users: vec![proto::User {
-                id: 6,
-                github_login: "maxbrunsfeld".into(),
-                avatar_url: "http://avatar.com/maxbrunsfeld".into(),
-                name: None,
-            }],
-        },
-    );
-
-    let channel = channel.await.unwrap();
-    channel.update(cx, |channel, _| {
-        assert_eq!(
-            channel
-                .messages_in_range(0..2)
-                .map(|message| (message.sender.github_login.clone(), message.body.clone()))
-                .collect::<Vec<_>>(),
-            &[
-                ("user-5".into(), "a".into()),
-                ("maxbrunsfeld".into(), "b".into())
-            ]
-        );
-    });
-
-    // Receive a new message.
-    server.send(proto::ChannelMessageSent {
-        channel_id,
-        message: Some(proto::ChannelMessage {
-            id: 12,
-            body: "c".into(),
-            timestamp: 1002,
-            sender_id: 7,
-            mentions: vec![],
-            nonce: Some(3.into()),
-            reply_to_message_id: None,
-            edited_at: None,
-        }),
-    });
-
-    // Client requests user for message since they haven't seen them yet
-    let get_users = server.receive::<proto::GetUsers>().await.unwrap();
-    assert_eq!(get_users.payload.user_ids, vec![7]);
-    server.respond(
-        get_users.receipt(),
-        proto::UsersResponse {
-            users: vec![proto::User {
-                id: 7,
-                github_login: "as-cii".into(),
-                avatar_url: "http://avatar.com/as-cii".into(),
-                name: None,
-            }],
-        },
-    );
-
-    assert_eq!(
-        channel.next_event(cx).await,
-        ChannelChatEvent::MessagesUpdated {
-            old_range: 2..2,
-            new_count: 1,
-        }
-    );
-    channel.update(cx, |channel, _| {
-        assert_eq!(
-            channel
-                .messages_in_range(2..3)
-                .map(|message| (message.sender.github_login.clone(), message.body.clone()))
-                .collect::<Vec<_>>(),
-            &[("as-cii".into(), "c".into())]
-        )
-    });
-
-    // Scroll up to view older messages.
-    channel.update(cx, |channel, cx| {
-        channel.load_more_messages(cx).unwrap().detach();
-    });
-    let get_messages = server.receive::<proto::GetChannelMessages>().await.unwrap();
-    assert_eq!(get_messages.payload.channel_id, 5);
-    assert_eq!(get_messages.payload.before_message_id, 10);
-    server.respond(
-        get_messages.receipt(),
-        proto::GetChannelMessagesResponse {
-            done: true,
-            messages: vec![
-                proto::ChannelMessage {
-                    id: 8,
-                    body: "y".into(),
-                    timestamp: 998,
-                    sender_id: 5,
-                    nonce: Some(4.into()),
-                    mentions: vec![],
-                    reply_to_message_id: None,
-                    edited_at: None,
-                },
-                proto::ChannelMessage {
-                    id: 9,
-                    body: "z".into(),
-                    timestamp: 999,
-                    sender_id: 6,
-                    nonce: Some(5.into()),
-                    mentions: vec![],
-                    reply_to_message_id: None,
-                    edited_at: None,
-                },
-            ],
-        },
-    );
-
-    assert_eq!(
-        channel.next_event(cx).await,
-        ChannelChatEvent::MessagesUpdated {
-            old_range: 0..0,
-            new_count: 2,
-        }
-    );
-    channel.update(cx, |channel, _| {
-        assert_eq!(
-            channel
-                .messages_in_range(0..2)
-                .map(|message| (message.sender.github_login.clone(), message.body.clone()))
-                .collect::<Vec<_>>(),
-            &[
-                ("user-5".into(), "y".into()),
-                ("maxbrunsfeld".into(), "z".into())
-            ]
-        );
-    });
-}
-
 fn init_test(cx: &mut App) -> Entity<ChannelStore> {
     let settings_store = SettingsStore::test(cx);
     cx.set_global(settings_store);
diff --git a/crates/client/Cargo.toml b/crates/client/Cargo.toml
index 5c6d1157fd710de0e1dd160b611c0bd7c6667c4d..01007cdc6618996735c859284e3860b936f540e8 100644
--- a/crates/client/Cargo.toml
+++ b/crates/client/Cargo.toml
@@ -75,7 +75,7 @@ util = { workspace = true, features = ["test-support"] }
 windows.workspace = true
 
 [target.'cfg(target_os = "macos")'.dependencies]
-cocoa.workspace = true
+objc2-foundation.workspace = true
 
 [target.'cfg(any(target_os = "windows", target_os = "macos"))'.dependencies]
 tokio-native-tls = "0.3"
diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs
index 1287b4563c99cbd387b3a18d98fbbc734e55e4db..cb8185c7ed326ed7d45726a99077c53903118316 100644
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -31,7 +31,7 @@ use release_channel::{AppVersion, ReleaseChannel};
 use rpc::proto::{AnyTypedEnvelope, EnvelopedMessage, PeerId, RequestMessage};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 use std::{
     any::TypeId,
     convert::TryFrom,
@@ -96,7 +96,8 @@ actions!(
     ]
 );
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey)]
+#[settings_key(None)]
 pub struct ClientSettingsContent {
     server_url: Option<String>,
 }
@@ -107,8 +108,6 @@ pub struct ClientSettings {
 }
 
 impl Settings for ClientSettings {
-    const KEY: Option<&'static str> = None;
-
     type FileContent = ClientSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
@@ -122,7 +121,8 @@ impl Settings for ClientSettings {
     fn import_from_vscode(_vscode: &settings::VsCodeSettings, _current: &mut Self::FileContent) {}
 }
 
-#[derive(Default, Clone, Serialize, Deserialize, JsonSchema, SettingsUi)]
+#[derive(Default, Clone, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey)]
+#[settings_key(None)]
 pub struct ProxySettingsContent {
     proxy: Option<String>,
 }
@@ -133,8 +133,6 @@ pub struct ProxySettings {
 }
 
 impl Settings for ProxySettings {
-    const KEY: Option<&'static str> = None;
-
     type FileContent = ProxySettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
@@ -527,7 +525,8 @@ pub struct TelemetrySettings {
 }
 
 /// Control what info is collected by Zed.
-#[derive(Default, Clone, Serialize, Deserialize, JsonSchema, Debug, SettingsUi)]
+#[derive(Default, Clone, Serialize, Deserialize, JsonSchema, Debug, SettingsUi, SettingsKey)]
+#[settings_key(key = "telemetry")]
 pub struct TelemetrySettingsContent {
     /// Send debug info like crash reports.
     ///
@@ -540,8 +539,6 @@ pub struct TelemetrySettingsContent {
 }
 
 impl settings::Settings for TelemetrySettings {
-    const KEY: Option<&'static str> = Some("telemetry");
-
     type FileContent = TelemetrySettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
@@ -691,7 +688,7 @@ impl Client {
                     #[cfg(any(test, feature = "test-support"))]
                     let mut rng = StdRng::seed_from_u64(0);
                     #[cfg(not(any(test, feature = "test-support")))]
-                    let mut rng = StdRng::from_entropy();
+                    let mut rng = StdRng::from_os_rng();
 
                     let mut delay = INITIAL_RECONNECTION_DELAY;
                     loop {
@@ -721,8 +718,9 @@ impl Client {
                                 },
                                 cx,
                             );
-                            let jitter =
-                                Duration::from_millis(rng.gen_range(0..delay.as_millis() as u64));
+                            let jitter = Duration::from_millis(
+                                rng.random_range(0..delay.as_millis() as u64),
+                            );
                             cx.background_executor().timer(delay + jitter).await;
                             delay = cmp::min(delay * 2, MAX_RECONNECTION_DELAY);
                         } else {
diff --git a/crates/client/src/telemetry.rs b/crates/client/src/telemetry.rs
index a5c1532c7563ab4bcb5f8826dcc18f3d52daf222..e3123400866516bda26b071e288bdad9dd5964e0 100644
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -84,6 +84,10 @@ static DOTNET_PROJECT_FILES_REGEX: LazyLock<Regex> = LazyLock::new(|| {
     Regex::new(r"^(global\.json|Directory\.Build\.props|.*\.(csproj|fsproj|vbproj|sln))$").unwrap()
 });
 
+#[cfg(target_os = "macos")]
+static MACOS_VERSION_REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"(\s*\(Build [^)]*[0-9]\))").unwrap());
+
 pub fn os_name() -> String {
     #[cfg(target_os = "macos")]
     {
@@ -108,19 +112,16 @@ pub fn os_name() -> String {
 pub fn os_version() -> String {
     #[cfg(target_os = "macos")]
     {
-        use cocoa::base::nil;
-        use cocoa::foundation::NSProcessInfo;
-
-        unsafe {
-            let process_info = cocoa::foundation::NSProcessInfo::processInfo(nil);
-            let version = process_info.operatingSystemVersion();
-            gpui::SemanticVersion::new(
-                version.majorVersion as usize,
-                version.minorVersion as usize,
-                version.patchVersion as usize,
-            )
+        use objc2_foundation::NSProcessInfo;
+        let process_info = NSProcessInfo::processInfo();
+        let version_nsstring = unsafe { process_info.operatingSystemVersionString() };
+        // "Version 15.6.1 (Build 24G90)" -> "15.6.1 (Build 24G90)"
+        let version_string = version_nsstring.to_string().replace("Version ", "");
+        // "15.6.1 (Build 24G90)" -> "15.6.1"
+        // "26.0.0 (Build 25A5349a)" -> unchanged (Beta or Rapid Security Response; ends with letter)
+        MACOS_VERSION_REGEX
+            .replace_all(&version_string, "")
             .to_string()
-        }
     }
     #[cfg(any(target_os = "linux", target_os = "freebsd"))]
     {
diff --git a/crates/cloud_llm_client/src/cloud_llm_client.rs b/crates/cloud_llm_client/src/cloud_llm_client.rs
index 741945af1087e7a4ff5edfc32cca4d080db3982f..4bc33079dafd244ae109a45bd12cd5f9cb506b2b 100644
--- a/crates/cloud_llm_client/src/cloud_llm_client.rs
+++ b/crates/cloud_llm_client/src/cloud_llm_client.rs
@@ -82,34 +82,10 @@ pub enum Plan {
     ZedFree,
     #[serde(alias = "ZedPro")]
     ZedPro,
+    ZedProV2,
     #[serde(alias = "ZedProTrial")]
     ZedProTrial,
-}
-
-impl Plan {
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            Plan::ZedFree => "zed_free",
-            Plan::ZedPro => "zed_pro",
-            Plan::ZedProTrial => "zed_pro_trial",
-        }
-    }
-
-    pub fn model_requests_limit(&self) -> UsageLimit {
-        match self {
-            Plan::ZedPro => UsageLimit::Limited(500),
-            Plan::ZedProTrial => UsageLimit::Limited(150),
-            Plan::ZedFree => UsageLimit::Limited(50),
-        }
-    }
-
-    pub fn edit_predictions_limit(&self) -> UsageLimit {
-        match self {
-            Plan::ZedPro => UsageLimit::Unlimited,
-            Plan::ZedProTrial => UsageLimit::Unlimited,
-            Plan::ZedFree => UsageLimit::Limited(2_000),
-        }
-    }
+    ZedProTrialV2,
 }
 
 impl FromStr for Plan {
@@ -353,6 +329,12 @@ mod tests {
 
         let plan = serde_json::from_value::<Plan>(json!("zed_pro_trial")).unwrap();
         assert_eq!(plan, Plan::ZedProTrial);
+
+        let plan = serde_json::from_value::<Plan>(json!("zed_pro_v2")).unwrap();
+        assert_eq!(plan, Plan::ZedProV2);
+
+        let plan = serde_json::from_value::<Plan>(json!("zed_pro_trial_v2")).unwrap();
+        assert_eq!(plan, Plan::ZedProTrialV2);
     }
 
     #[test]
diff --git a/crates/collab/src/auth.rs b/crates/collab/src/auth.rs
index e484d6b510f444e764ac38210d6a5cfc42142807..13296b79ae8b3df97753e7adf4f2078990c187b0 100644
--- a/crates/collab/src/auth.rs
+++ b/crates/collab/src/auth.rs
@@ -227,7 +227,7 @@ pub async fn verify_access_token(
 
 #[cfg(test)]
 mod test {
-    use rand::thread_rng;
+    use rand::prelude::*;
     use scrypt::password_hash::{PasswordHasher, SaltString};
     use sea_orm::EntityTrait;
 
@@ -358,9 +358,42 @@ mod test {
                 None,
                 None,
                 params,
-                &SaltString::generate(thread_rng()),
+                &SaltString::generate(PasswordHashRngCompat::new()),
             )
             .map_err(anyhow::Error::new)?
             .to_string())
     }
+
+    // TODO: remove once we password_hash v0.6 is released.
+    struct PasswordHashRngCompat(rand::rngs::ThreadRng);
+
+    impl PasswordHashRngCompat {
+        fn new() -> Self {
+            Self(rand::rng())
+        }
+    }
+
+    impl scrypt::password_hash::rand_core::RngCore for PasswordHashRngCompat {
+        fn next_u32(&mut self) -> u32 {
+            self.0.next_u32()
+        }
+
+        fn next_u64(&mut self) -> u64 {
+            self.0.next_u64()
+        }
+
+        fn fill_bytes(&mut self, dest: &mut [u8]) {
+            self.0.fill_bytes(dest);
+        }
+
+        fn try_fill_bytes(
+            &mut self,
+            dest: &mut [u8],
+        ) -> Result<(), scrypt::password_hash::rand_core::Error> {
+            self.fill_bytes(dest);
+            Ok(())
+        }
+    }
+
+    impl scrypt::password_hash::rand_core::CryptoRng for PasswordHashRngCompat {}
 }
diff --git a/crates/collab/src/db.rs b/crates/collab/src/db.rs
index 95a485305ca31bde351f4962d1678e30801d8a01..6ec57ce95e1863d973624f57947b28fffec042b1 100644
--- a/crates/collab/src/db.rs
+++ b/crates/collab/src/db.rs
@@ -26,7 +26,6 @@ use semantic_version::SemanticVersion;
 use serde::{Deserialize, Serialize};
 use std::ops::RangeInclusive;
 use std::{
-    fmt::Write as _,
     future::Future,
     marker::PhantomData,
     ops::{Deref, DerefMut},
@@ -256,7 +255,7 @@ impl Database {
             let test_options = self.test_options.as_ref().unwrap();
             test_options.executor.simulate_random_delay().await;
             let fail_probability = *test_options.query_failure_probability.lock();
-            if test_options.executor.rng().gen_bool(fail_probability) {
+            if test_options.executor.rng().random_bool(fail_probability) {
                 return Err(anyhow!("simulated query failure"))?;
             }
 
@@ -486,9 +485,7 @@ pub struct ChannelsForUser {
     pub invited_channels: Vec<Channel>,
 
     pub observed_buffer_versions: Vec<proto::ChannelBufferVersion>,
-    pub observed_channel_messages: Vec<proto::ChannelMessageId>,
     pub latest_buffer_versions: Vec<proto::ChannelBufferVersion>,
-    pub latest_channel_messages: Vec<proto::ChannelMessageId>,
 }
 
 #[derive(Debug)]
diff --git a/crates/collab/src/db/queries.rs b/crates/collab/src/db/queries.rs
index 95e45dc00451dae27a98fd68c492f1047dea9804..7b457a5da438e0a9ab7c6cd79368b2845e962318 100644
--- a/crates/collab/src/db/queries.rs
+++ b/crates/collab/src/db/queries.rs
@@ -7,7 +7,6 @@ pub mod contacts;
 pub mod contributors;
 pub mod embeddings;
 pub mod extensions;
-pub mod messages;
 pub mod notifications;
 pub mod projects;
 pub mod rooms;
diff --git a/crates/collab/src/db/queries/channels.rs b/crates/collab/src/db/queries/channels.rs
index 5e296e0a3b8e3cb16bd0a1820688d808e10a8193..4bb82865e73968e2861777d5cd0f700675366e81 100644
--- a/crates/collab/src/db/queries/channels.rs
+++ b/crates/collab/src/db/queries/channels.rs
@@ -618,25 +618,17 @@ impl Database {
         }
         drop(rows);
 
-        let latest_channel_messages = self.latest_channel_messages(&channel_ids, tx).await?;
-
         let observed_buffer_versions = self
             .observed_channel_buffer_changes(&channel_ids_by_buffer_id, user_id, tx)
             .await?;
 
-        let observed_channel_messages = self
-            .observed_channel_messages(&channel_ids, user_id, tx)
-            .await?;
-
         Ok(ChannelsForUser {
             channel_memberships,
             channels,
             invited_channels,
             channel_participants,
             latest_buffer_versions,
-            latest_channel_messages,
             observed_buffer_versions,
-            observed_channel_messages,
         })
     }
 
diff --git a/crates/collab/src/db/queries/messages.rs b/crates/collab/src/db/queries/messages.rs
deleted file mode 100644
index 38e100053c0e88311aacd69a14fd8cb98e43ee28..0000000000000000000000000000000000000000
--- a/crates/collab/src/db/queries/messages.rs
+++ /dev/null
@@ -1,725 +0,0 @@
-use super::*;
-use anyhow::Context as _;
-use rpc::Notification;
-use sea_orm::{SelectColumns, TryInsertResult};
-use time::OffsetDateTime;
-use util::ResultExt;
-
-impl Database {
-    /// Inserts a record representing a user joining the chat for a given channel.
-    pub async fn join_channel_chat(
-        &self,
-        channel_id: ChannelId,
-        connection_id: ConnectionId,
-        user_id: UserId,
-    ) -> Result<()> {
-        self.transaction(|tx| async move {
-            let channel = self.get_channel_internal(channel_id, &tx).await?;
-            self.check_user_is_channel_participant(&channel, user_id, &tx)
-                .await?;
-            channel_chat_participant::ActiveModel {
-                id: ActiveValue::NotSet,
-                channel_id: ActiveValue::Set(channel_id),
-                user_id: ActiveValue::Set(user_id),
-                connection_id: ActiveValue::Set(connection_id.id as i32),
-                connection_server_id: ActiveValue::Set(ServerId(connection_id.owner_id as i32)),
-            }
-            .insert(&*tx)
-            .await?;
-            Ok(())
-        })
-        .await
-    }
-
-    /// Removes `channel_chat_participant` records associated with the given connection ID.
-    pub async fn channel_chat_connection_lost(
-        &self,
-        connection_id: ConnectionId,
-        tx: &DatabaseTransaction,
-    ) -> Result<()> {
-        channel_chat_participant::Entity::delete_many()
-            .filter(
-                Condition::all()
-                    .add(
-                        channel_chat_participant::Column::ConnectionServerId
-                            .eq(connection_id.owner_id),
-                    )
-                    .add(channel_chat_participant::Column::ConnectionId.eq(connection_id.id)),
-            )
-            .exec(tx)
-            .await?;
-        Ok(())
-    }
-
-    /// Removes `channel_chat_participant` records associated with the given user ID so they
-    /// will no longer get chat notifications.
-    pub async fn leave_channel_chat(
-        &self,
-        channel_id: ChannelId,
-        connection_id: ConnectionId,
-        _user_id: UserId,
-    ) -> Result<()> {
-        self.transaction(|tx| async move {
-            channel_chat_participant::Entity::delete_many()
-                .filter(
-                    Condition::all()
-                        .add(
-                            channel_chat_participant::Column::ConnectionServerId
-                                .eq(connection_id.owner_id),
-                        )
-                        .add(channel_chat_participant::Column::ConnectionId.eq(connection_id.id))
-                        .add(channel_chat_participant::Column::ChannelId.eq(channel_id)),
-                )
-                .exec(&*tx)
-                .await?;
-
-            Ok(())
-        })
-        .await
-    }
-
-    /// Retrieves the messages in the specified channel.
-    ///
-    /// Use `before_message_id` to paginate through the channel's messages.
-    pub async fn get_channel_messages(
-        &self,
-        channel_id: ChannelId,
-        user_id: UserId,
-        count: usize,
-        before_message_id: Option<MessageId>,
-    ) -> Result<Vec<proto::ChannelMessage>> {
-        self.transaction(|tx| async move {
-            let channel = self.get_channel_internal(channel_id, &tx).await?;
-            self.check_user_is_channel_participant(&channel, user_id, &tx)
-                .await?;
-
-            let mut condition =
-                Condition::all().add(channel_message::Column::ChannelId.eq(channel_id));
-
-            if let Some(before_message_id) = before_message_id {
-                condition = condition.add(channel_message::Column::Id.lt(before_message_id));
-            }
-
-            let rows = channel_message::Entity::find()
-                .filter(condition)
-                .order_by_desc(channel_message::Column::Id)
-                .limit(count as u64)
-                .all(&*tx)
-                .await?;
-
-            self.load_channel_messages(rows, &tx).await
-        })
-        .await
-    }
-
-    /// Returns the channel messages with the given IDs.
-    pub async fn get_channel_messages_by_id(
-        &self,
-        user_id: UserId,
-        message_ids: &[MessageId],
-    ) -> Result<Vec<proto::ChannelMessage>> {
-        self.transaction(|tx| async move {
-            let rows = channel_message::Entity::find()
-                .filter(channel_message::Column::Id.is_in(message_ids.iter().copied()))
-                .order_by_desc(channel_message::Column::Id)
-                .all(&*tx)
-                .await?;
-
-            let mut channels = HashMap::<ChannelId, channel::Model>::default();
-            for row in &rows {
-                channels.insert(
-                    row.channel_id,
-                    self.get_channel_internal(row.channel_id, &tx).await?,
-                );
-            }
-
-            for (_, channel) in channels {
-                self.check_user_is_channel_participant(&channel, user_id, &tx)
-                    .await?;
-            }
-
-            let messages = self.load_channel_messages(rows, &tx).await?;
-            Ok(messages)
-        })
-        .await
-    }
-
-    async fn load_channel_messages(
-        &self,
-        rows: Vec<channel_message::Model>,
-        tx: &DatabaseTransaction,
-    ) -> Result<Vec<proto::ChannelMessage>> {
-        let mut messages = rows
-            .into_iter()
-            .map(|row| {
-                let nonce = row.nonce.as_u64_pair();
-                proto::ChannelMessage {
-                    id: row.id.to_proto(),
-                    sender_id: row.sender_id.to_proto(),
-                    body: row.body,
-                    timestamp: row.sent_at.assume_utc().unix_timestamp() as u64,
-                    mentions: vec![],
-                    nonce: Some(proto::Nonce {
-                        upper_half: nonce.0,
-                        lower_half: nonce.1,
-                    }),
-                    reply_to_message_id: row.reply_to_message_id.map(|id| id.to_proto()),
-                    edited_at: row
-                        .edited_at
-                        .map(|t| t.assume_utc().unix_timestamp() as u64),
-                }
-            })
-            .collect::<Vec<_>>();
-        messages.reverse();
-
-        let mut mentions = channel_message_mention::Entity::find()
-            .filter(channel_message_mention::Column::MessageId.is_in(messages.iter().map(|m| m.id)))
-            .order_by_asc(channel_message_mention::Column::MessageId)
-            .order_by_asc(channel_message_mention::Column::StartOffset)
-            .stream(tx)
-            .await?;
-
-        let mut message_ix = 0;
-        while let Some(mention) = mentions.next().await {
-            let mention = mention?;
-            let message_id = mention.message_id.to_proto();
-            while let Some(message) = messages.get_mut(message_ix) {
-                if message.id < message_id {
-                    message_ix += 1;
-                } else {
-                    if message.id == message_id {
-                        message.mentions.push(proto::ChatMention {
-                            range: Some(proto::Range {
-                                start: mention.start_offset as u64,
-                                end: mention.end_offset as u64,
-                            }),
-                            user_id: mention.user_id.to_proto(),
-                        });
-                    }
-                    break;
-                }
-            }
-        }
-
-        Ok(messages)
-    }
-
-    fn format_mentions_to_entities(
-        &self,
-        message_id: MessageId,
-        body: &str,
-        mentions: &[proto::ChatMention],
-    ) -> Result<Vec<tables::channel_message_mention::ActiveModel>> {
-        Ok(mentions
-            .iter()
-            .filter_map(|mention| {
-                let range = mention.range.as_ref()?;
-                if !body.is_char_boundary(range.start as usize)
-                    || !body.is_char_boundary(range.end as usize)
-                {
-                    return None;
-                }
-                Some(channel_message_mention::ActiveModel {
-                    message_id: ActiveValue::Set(message_id),
-                    start_offset: ActiveValue::Set(range.start as i32),
-                    end_offset: ActiveValue::Set(range.end as i32),
-                    user_id: ActiveValue::Set(UserId::from_proto(mention.user_id)),
-                })
-            })
-            .collect::<Vec<_>>())
-    }
-
-    /// Creates a new channel message.
-    pub async fn create_channel_message(
-        &self,
-        channel_id: ChannelId,
-        user_id: UserId,
-        body: &str,
-        mentions: &[proto::ChatMention],
-        timestamp: OffsetDateTime,
-        nonce: u128,
-        reply_to_message_id: Option<MessageId>,
-    ) -> Result<CreatedChannelMessage> {
-        self.transaction(|tx| async move {
-            let channel = self.get_channel_internal(channel_id, &tx).await?;
-            self.check_user_is_channel_participant(&channel, user_id, &tx)
-                .await?;
-
-            let mut rows = channel_chat_participant::Entity::find()
-                .filter(channel_chat_participant::Column::ChannelId.eq(channel_id))
-                .stream(&*tx)
-                .await?;
-
-            let mut is_participant = false;
-            let mut participant_connection_ids = HashSet::default();
-            let mut participant_user_ids = Vec::new();
-            while let Some(row) = rows.next().await {
-                let row = row?;
-                if row.user_id == user_id {
-                    is_participant = true;
-                }
-                participant_user_ids.push(row.user_id);
-                participant_connection_ids.insert(row.connection());
-            }
-            drop(rows);
-
-            if !is_participant {
-                Err(anyhow!("not a chat participant"))?;
-            }
-
-            let timestamp = timestamp.to_offset(time::UtcOffset::UTC);
-            let timestamp = time::PrimitiveDateTime::new(timestamp.date(), timestamp.time());
-
-            let result = channel_message::Entity::insert(channel_message::ActiveModel {
-                channel_id: ActiveValue::Set(channel_id),
-                sender_id: ActiveValue::Set(user_id),
-                body: ActiveValue::Set(body.to_string()),
-                sent_at: ActiveValue::Set(timestamp),
-                nonce: ActiveValue::Set(Uuid::from_u128(nonce)),
-                id: ActiveValue::NotSet,
-                reply_to_message_id: ActiveValue::Set(reply_to_message_id),
-                edited_at: ActiveValue::NotSet,
-            })
-            .on_conflict(
-                OnConflict::columns([
-                    channel_message::Column::SenderId,
-                    channel_message::Column::Nonce,
-                ])
-                .do_nothing()
-                .to_owned(),
-            )
-            .do_nothing()
-            .exec(&*tx)
-            .await?;
-
-            let message_id;
-            let mut notifications = Vec::new();
-            match result {
-                TryInsertResult::Inserted(result) => {
-                    message_id = result.last_insert_id;
-                    let mentioned_user_ids =
-                        mentions.iter().map(|m| m.user_id).collect::<HashSet<_>>();
-
-                    let mentions = self.format_mentions_to_entities(message_id, body, mentions)?;
-                    if !mentions.is_empty() {
-                        channel_message_mention::Entity::insert_many(mentions)
-                            .exec(&*tx)
-                            .await?;
-                    }
-
-                    for mentioned_user in mentioned_user_ids {
-                        notifications.extend(
-                            self.create_notification(
-                                UserId::from_proto(mentioned_user),
-                                rpc::Notification::ChannelMessageMention {
-                                    message_id: message_id.to_proto(),
-                                    sender_id: user_id.to_proto(),
-                                    channel_id: channel_id.to_proto(),
-                                },
-                                false,
-                                &tx,
-                            )
-                            .await?,
-                        );
-                    }
-
-                    self.observe_channel_message_internal(channel_id, user_id, message_id, &tx)
-                        .await?;
-                }
-                _ => {
-                    message_id = channel_message::Entity::find()
-                        .filter(channel_message::Column::Nonce.eq(Uuid::from_u128(nonce)))
-                        .one(&*tx)
-                        .await?
-                        .context("failed to insert message")?
-                        .id;
-                }
-            }
-
-            Ok(CreatedChannelMessage {
-                message_id,
-                participant_connection_ids,
-                notifications,
-            })
-        })
-        .await
-    }
-
-    pub async fn observe_channel_message(
-        &self,
-        channel_id: ChannelId,
-        user_id: UserId,
-        message_id: MessageId,
-    ) -> Result<NotificationBatch> {
-        self.transaction(|tx| async move {
-            self.observe_channel_message_internal(channel_id, user_id, message_id, &tx)
-                .await?;
-            let mut batch = NotificationBatch::default();
-            batch.extend(
-                self.mark_notification_as_read(
-                    user_id,
-                    &Notification::ChannelMessageMention {
-                        message_id: message_id.to_proto(),
-                        sender_id: Default::default(),
-                        channel_id: Default::default(),
-                    },
-                    &tx,
-                )
-                .await?,
-            );
-            Ok(batch)
-        })
-        .await
-    }
-
-    async fn observe_channel_message_internal(
-        &self,
-        channel_id: ChannelId,
-        user_id: UserId,
-        message_id: MessageId,
-        tx: &DatabaseTransaction,
-    ) -> Result<()> {
-        observed_channel_messages::Entity::insert(observed_channel_messages::ActiveModel {
-            user_id: ActiveValue::Set(user_id),
-            channel_id: ActiveValue::Set(channel_id),
-            channel_message_id: ActiveValue::Set(message_id),
-        })
-        .on_conflict(
-            OnConflict::columns([
-                observed_channel_messages::Column::ChannelId,
-                observed_channel_messages::Column::UserId,
-            ])
-            .update_column(observed_channel_messages::Column::ChannelMessageId)
-            .action_cond_where(observed_channel_messages::Column::ChannelMessageId.lt(message_id))
-            .to_owned(),
-        )
-        // TODO: Try to upgrade SeaORM so we don't have to do this hack around their bug
-        .exec_without_returning(tx)
-        .await?;
-        Ok(())
-    }
-
-    pub async fn observed_channel_messages(
-        &self,
-        channel_ids: &[ChannelId],
-        user_id: UserId,
-        tx: &DatabaseTransaction,
-    ) -> Result<Vec<proto::ChannelMessageId>> {
-        let rows = observed_channel_messages::Entity::find()
-            .filter(observed_channel_messages::Column::UserId.eq(user_id))
-            .filter(
-                observed_channel_messages::Column::ChannelId
-                    .is_in(channel_ids.iter().map(|id| id.0)),
-            )
-            .all(tx)
-            .await?;
-
-        Ok(rows
-            .into_iter()
-            .map(|message| proto::ChannelMessageId {
-                channel_id: message.channel_id.to_proto(),
-                message_id: message.channel_message_id.to_proto(),
-            })
-            .collect())
-    }
-
-    pub async fn latest_channel_messages(
-        &self,
-        channel_ids: &[ChannelId],
-        tx: &DatabaseTransaction,
-    ) -> Result<Vec<proto::ChannelMessageId>> {
-        let mut values = String::new();
-        for id in channel_ids {
-            if !values.is_empty() {
-                values.push_str(", ");
-            }
-            write!(&mut values, "({})", id).unwrap();
-        }
-
-        if values.is_empty() {
-            return Ok(Vec::default());
-        }
-
-        let sql = format!(
-            r#"
-            SELECT
-                *
-            FROM (
-                SELECT
-                    *,
-                    row_number() OVER (
-                        PARTITION BY channel_id
-                        ORDER BY id DESC
-                    ) as row_number
-                FROM channel_messages
-                WHERE
-                    channel_id in ({values})
-            ) AS messages
-            WHERE
-                row_number = 1
-            "#,
-        );
-
-        let stmt = Statement::from_string(self.pool.get_database_backend(), sql);
-        let mut last_messages = channel_message::Model::find_by_statement(stmt)
-            .stream(tx)
-            .await?;
-
-        let mut results = Vec::new();
-        while let Some(result) = last_messages.next().await {
-            let message = result?;
-            results.push(proto::ChannelMessageId {
-                channel_id: message.channel_id.to_proto(),
-                message_id: message.id.to_proto(),
-            });
-        }
-
-        Ok(results)
-    }
-
-    fn get_notification_kind_id_by_name(&self, notification_kind: &str) -> Option<i32> {
-        self.notification_kinds_by_id
-            .iter()
-            .find(|(_, kind)| **kind == notification_kind)
-            .map(|kind| kind.0.0)
-    }
-
-    /// Removes the channel message with the given ID.
-    pub async fn remove_channel_message(
-        &self,
-        channel_id: ChannelId,
-        message_id: MessageId,
-        user_id: UserId,
-    ) -> Result<(Vec<ConnectionId>, Vec<NotificationId>)> {
-        self.transaction(|tx| async move {
-            let mut rows = channel_chat_participant::Entity::find()
-                .filter(channel_chat_participant::Column::ChannelId.eq(channel_id))
-                .stream(&*tx)
-                .await?;
-
-            let mut is_participant = false;
-            let mut participant_connection_ids = Vec::new();
-            while let Some(row) = rows.next().await {
-                let row = row?;
-                if row.user_id == user_id {
-                    is_participant = true;
-                }
-                participant_connection_ids.push(row.connection());
-            }
-            drop(rows);
-
-            if !is_participant {
-                Err(anyhow!("not a chat participant"))?;
-            }
-
-            let result = channel_message::Entity::delete_by_id(message_id)
-                .filter(channel_message::Column::SenderId.eq(user_id))
-                .exec(&*tx)
-                .await?;
-
-            if result.rows_affected == 0 {
-                let channel = self.get_channel_internal(channel_id, &tx).await?;
-                if self
-                    .check_user_is_channel_admin(&channel, user_id, &tx)
-                    .await
-                    .is_ok()
-                {
-                    let result = channel_message::Entity::delete_by_id(message_id)
-                        .exec(&*tx)
-                        .await?;
-                    if result.rows_affected == 0 {
-                        Err(anyhow!("no such message"))?;
-                    }
-                } else {
-                    Err(anyhow!("operation could not be completed"))?;
-                }
-            }
-
-            let notification_kind_id =
-                self.get_notification_kind_id_by_name("ChannelMessageMention");
-
-            let existing_notifications = notification::Entity::find()
-                .filter(notification::Column::EntityId.eq(message_id))
-                .filter(notification::Column::Kind.eq(notification_kind_id))
-                .select_column(notification::Column::Id)
-                .all(&*tx)
-                .await?;
-
-            let existing_notification_ids = existing_notifications
-                .into_iter()
-                .map(|notification| notification.id)
-                .collect();
-
-            // remove all the mention notifications for this message
-            notification::Entity::delete_many()
-                .filter(notification::Column::EntityId.eq(message_id))
-                .filter(notification::Column::Kind.eq(notification_kind_id))
-                .exec(&*tx)
-                .await?;
-
-            Ok((participant_connection_ids, existing_notification_ids))
-        })
-        .await
-    }
-
-    /// Updates the channel message with the given ID, body and timestamp(edited_at).
-    pub async fn update_channel_message(
-        &self,
-        channel_id: ChannelId,
-        message_id: MessageId,
-        user_id: UserId,
-        body: &str,
-        mentions: &[proto::ChatMention],
-        edited_at: OffsetDateTime,
-    ) -> Result<UpdatedChannelMessage> {
-        self.transaction(|tx| async move {
-            let channel = self.get_channel_internal(channel_id, &tx).await?;
-            self.check_user_is_channel_participant(&channel, user_id, &tx)
-                .await?;
-
-            let mut rows = channel_chat_participant::Entity::find()
-                .filter(channel_chat_participant::Column::ChannelId.eq(channel_id))
-                .stream(&*tx)
-                .await?;
-
-            let mut is_participant = false;
-            let mut participant_connection_ids = Vec::new();
-            let mut participant_user_ids = Vec::new();
-            while let Some(row) = rows.next().await {
-                let row = row?;
-                if row.user_id == user_id {
-                    is_participant = true;
-                }
-                participant_user_ids.push(row.user_id);
-                participant_connection_ids.push(row.connection());
-            }
-            drop(rows);
-
-            if !is_participant {
-                Err(anyhow!("not a chat participant"))?;
-            }
-
-            let channel_message = channel_message::Entity::find_by_id(message_id)
-                .filter(channel_message::Column::SenderId.eq(user_id))
-                .one(&*tx)
-                .await?;
-
-            let Some(channel_message) = channel_message else {
-                Err(anyhow!("Channel message not found"))?
-            };
-
-            let edited_at = edited_at.to_offset(time::UtcOffset::UTC);
-            let edited_at = time::PrimitiveDateTime::new(edited_at.date(), edited_at.time());
-
-            let updated_message = channel_message::ActiveModel {
-                body: ActiveValue::Set(body.to_string()),
-                edited_at: ActiveValue::Set(Some(edited_at)),
-                reply_to_message_id: ActiveValue::Unchanged(channel_message.reply_to_message_id),
-                id: ActiveValue::Unchanged(message_id),
-                channel_id: ActiveValue::Unchanged(channel_id),
-                sender_id: ActiveValue::Unchanged(user_id),
-                sent_at: ActiveValue::Unchanged(channel_message.sent_at),
-                nonce: ActiveValue::Unchanged(channel_message.nonce),
-            };
-
-            let result = channel_message::Entity::update_many()
-                .set(updated_message)
-                .filter(channel_message::Column::Id.eq(message_id))
-                .filter(channel_message::Column::SenderId.eq(user_id))
-                .exec(&*tx)
-                .await?;
-            if result.rows_affected == 0 {
-                return Err(anyhow!(
-                    "Attempted to edit a message (id: {message_id}) which does not exist anymore."
-                ))?;
-            }
-
-            // we have to fetch the old mentions,
-            // so we don't send a notification when the message has been edited that you are mentioned in
-            let old_mentions = channel_message_mention::Entity::find()
-                .filter(channel_message_mention::Column::MessageId.eq(message_id))
-                .all(&*tx)
-                .await?;
-
-            // remove all existing mentions
-            channel_message_mention::Entity::delete_many()
-                .filter(channel_message_mention::Column::MessageId.eq(message_id))
-                .exec(&*tx)
-                .await?;
-
-            let new_mentions = self.format_mentions_to_entities(message_id, body, mentions)?;
-            if !new_mentions.is_empty() {
-                // insert new mentions
-                channel_message_mention::Entity::insert_many(new_mentions)
-                    .exec(&*tx)
-                    .await?;
-            }
-
-            let mut update_mention_user_ids = HashSet::default();
-            let mut new_mention_user_ids =
-                mentions.iter().map(|m| m.user_id).collect::<HashSet<_>>();
-            // Filter out users that were mentioned before
-            for mention in &old_mentions {
-                if new_mention_user_ids.contains(&mention.user_id.to_proto()) {
-                    update_mention_user_ids.insert(mention.user_id.to_proto());
-                }
-
-                new_mention_user_ids.remove(&mention.user_id.to_proto());
-            }
-
-            let notification_kind_id =
-                self.get_notification_kind_id_by_name("ChannelMessageMention");
-
-            let existing_notifications = notification::Entity::find()
-                .filter(notification::Column::EntityId.eq(message_id))
-                .filter(notification::Column::Kind.eq(notification_kind_id))
-                .all(&*tx)
-                .await?;
-
-            // determine which notifications should be updated or deleted
-            let mut deleted_notification_ids = HashSet::default();
-            let mut updated_mention_notifications = Vec::new();
-            for notification in existing_notifications {
-                if update_mention_user_ids.contains(&notification.recipient_id.to_proto()) {
-                    if let Some(notification) =
-                        self::notifications::model_to_proto(self, notification).log_err()
-                    {
-                        updated_mention_notifications.push(notification);
-                    }
-                } else {
-                    deleted_notification_ids.insert(notification.id);
-                }
-            }
-
-            let mut notifications = Vec::new();
-            for mentioned_user in new_mention_user_ids {
-                notifications.extend(
-                    self.create_notification(
-                        UserId::from_proto(mentioned_user),
-                        rpc::Notification::ChannelMessageMention {
-                            message_id: message_id.to_proto(),
-                            sender_id: user_id.to_proto(),
-                            channel_id: channel_id.to_proto(),
-                        },
-                        false,
-                        &tx,
-                    )
-                    .await?,
-                );
-            }
-
-            Ok(UpdatedChannelMessage {
-                message_id,
-                participant_connection_ids,
-                notifications,
-                reply_to_message_id: channel_message.reply_to_message_id,
-                timestamp: channel_message.sent_at,
-                deleted_mention_notification_ids: deleted_notification_ids
-                    .into_iter()
-                    .collect::<Vec<_>>(),
-                updated_mention_notifications,
-            })
-        })
-        .await
-    }
-}
diff --git a/crates/collab/src/db/queries/rooms.rs b/crates/collab/src/db/queries/rooms.rs
index 0713ac2cb2810797b319b53583bc8c0e1756fe68..b4cca2a2b15de0c10a641e847c32d2dfe300deb2 100644
--- a/crates/collab/src/db/queries/rooms.rs
+++ b/crates/collab/src/db/queries/rooms.rs
@@ -1193,7 +1193,6 @@ impl Database {
         self.transaction(|tx| async move {
             self.room_connection_lost(connection, &tx).await?;
             self.channel_buffer_connection_lost(connection, &tx).await?;
-            self.channel_chat_connection_lost(connection, &tx).await?;
             Ok(())
         })
         .await
diff --git a/crates/collab/src/db/tests.rs b/crates/collab/src/db/tests.rs
index 2eb8d377acaba9f8fe5ea558a29cc028c2aa11fd..25e03f1320a25455ede347b43477761d591fbd57 100644
--- a/crates/collab/src/db/tests.rs
+++ b/crates/collab/src/db/tests.rs
@@ -7,7 +7,6 @@ mod db_tests;
 mod embedding_tests;
 mod extension_tests;
 mod feature_flag_tests;
-mod message_tests;
 mod user_tests;
 
 use crate::migrations::run_database_migrations;
@@ -21,7 +20,7 @@ use sqlx::migrate::MigrateDatabase;
 use std::{
     sync::{
         Arc,
-        atomic::{AtomicI32, AtomicU32, Ordering::SeqCst},
+        atomic::{AtomicI32, Ordering::SeqCst},
     },
     time::Duration,
 };
@@ -75,10 +74,10 @@ impl TestDb {
         static LOCK: Mutex<()> = Mutex::new(());
 
         let _guard = LOCK.lock();
-        let mut rng = StdRng::from_entropy();
+        let mut rng = StdRng::from_os_rng();
         let url = format!(
             "postgres://postgres@localhost/zed-test-{}",
-            rng.r#gen::<u128>()
+            rng.random::<u128>()
         );
         let runtime = tokio::runtime::Builder::new_current_thread()
             .enable_io()
@@ -224,11 +223,3 @@ async fn new_test_user(db: &Arc<Database>, email: &str) -> UserId {
     .unwrap()
     .user_id
 }
-
-static TEST_CONNECTION_ID: AtomicU32 = AtomicU32::new(1);
-fn new_test_connection(server: ServerId) -> ConnectionId {
-    ConnectionId {
-        id: TEST_CONNECTION_ID.fetch_add(1, SeqCst),
-        owner_id: server.0 as u32,
-    }
-}
diff --git a/crates/collab/src/db/tests/channel_tests.rs b/crates/collab/src/db/tests/channel_tests.rs
index 1dd16fb50a8d002d01e27cec0a959fd9ea9ecde7..705dbba5ead0170acd629149b8d77b847a5784b0 100644
--- a/crates/collab/src/db/tests/channel_tests.rs
+++ b/crates/collab/src/db/tests/channel_tests.rs
@@ -1,7 +1,7 @@
 use crate::{
     db::{
         Channel, ChannelId, ChannelRole, Database, NewUserParams, RoomId, UserId,
-        tests::{assert_channel_tree_matches, channel_tree, new_test_connection, new_test_user},
+        tests::{assert_channel_tree_matches, channel_tree, new_test_user},
     },
     test_both_dbs,
 };
@@ -949,41 +949,6 @@ async fn test_user_is_channel_participant(db: &Arc<Database>) {
     )
 }
 
-test_both_dbs!(
-    test_guest_access,
-    test_guest_access_postgres,
-    test_guest_access_sqlite
-);
-
-async fn test_guest_access(db: &Arc<Database>) {
-    let server = db.create_server("test").await.unwrap();
-
-    let admin = new_test_user(db, "admin@example.com").await;
-    let guest = new_test_user(db, "guest@example.com").await;
-    let guest_connection = new_test_connection(server);
-
-    let zed_channel = db.create_root_channel("zed", admin).await.unwrap();
-    db.set_channel_visibility(zed_channel, crate::db::ChannelVisibility::Public, admin)
-        .await
-        .unwrap();
-
-    assert!(
-        db.join_channel_chat(zed_channel, guest_connection, guest)
-            .await
-            .is_err()
-    );
-
-    db.join_channel(zed_channel, guest, guest_connection)
-        .await
-        .unwrap();
-
-    assert!(
-        db.join_channel_chat(zed_channel, guest_connection, guest)
-            .await
-            .is_ok()
-    )
-}
-
 #[track_caller]
 fn assert_channel_tree(actual: Vec<Channel>, expected: &[(ChannelId, &[ChannelId])]) {
     let actual = actual
diff --git a/crates/collab/src/db/tests/message_tests.rs b/crates/collab/src/db/tests/message_tests.rs
deleted file mode 100644
index e20473d3bdd4179309c4d392f1df93f20f1e928c..0000000000000000000000000000000000000000
--- a/crates/collab/src/db/tests/message_tests.rs
+++ /dev/null
@@ -1,421 +0,0 @@
-use super::new_test_user;
-use crate::{
-    db::{ChannelRole, Database, MessageId},
-    test_both_dbs,
-};
-use channel::mentions_to_proto;
-use std::sync::Arc;
-use time::OffsetDateTime;
-
-test_both_dbs!(
-    test_channel_message_retrieval,
-    test_channel_message_retrieval_postgres,
-    test_channel_message_retrieval_sqlite
-);
-
-async fn test_channel_message_retrieval(db: &Arc<Database>) {
-    let user = new_test_user(db, "user@example.com").await;
-    let channel = db.create_channel("channel", None, user).await.unwrap().0;
-
-    let owner_id = db.create_server("test").await.unwrap().0 as u32;
-    db.join_channel_chat(channel.id, rpc::ConnectionId { owner_id, id: 0 }, user)
-        .await
-        .unwrap();
-
-    let mut all_messages = Vec::new();
-    for i in 0..10 {
-        all_messages.push(
-            db.create_channel_message(
-                channel.id,
-                user,
-                &i.to_string(),
-                &[],
-                OffsetDateTime::now_utc(),
-                i,
-                None,
-            )
-            .await
-            .unwrap()
-            .message_id
-            .to_proto(),
-        );
-    }
-
-    let messages = db
-        .get_channel_messages(channel.id, user, 3, None)
-        .await
-        .unwrap()
-        .into_iter()
-        .map(|message| message.id)
-        .collect::<Vec<_>>();
-    assert_eq!(messages, &all_messages[7..10]);
-
-    let messages = db
-        .get_channel_messages(
-            channel.id,
-            user,
-            4,
-            Some(MessageId::from_proto(all_messages[6])),
-        )
-        .await
-        .unwrap()
-        .into_iter()
-        .map(|message| message.id)
-        .collect::<Vec<_>>();
-    assert_eq!(messages, &all_messages[2..6]);
-}
-
-test_both_dbs!(
-    test_channel_message_nonces,
-    test_channel_message_nonces_postgres,
-    test_channel_message_nonces_sqlite
-);
-
-async fn test_channel_message_nonces(db: &Arc<Database>) {
-    let user_a = new_test_user(db, "user_a@example.com").await;
-    let user_b = new_test_user(db, "user_b@example.com").await;
-    let user_c = new_test_user(db, "user_c@example.com").await;
-    let channel = db.create_root_channel("channel", user_a).await.unwrap();
-    db.invite_channel_member(channel, user_b, user_a, ChannelRole::Member)
-        .await
-        .unwrap();
-    db.invite_channel_member(channel, user_c, user_a, ChannelRole::Member)
-        .await
-        .unwrap();
-    db.respond_to_channel_invite(channel, user_b, true)
-        .await
-        .unwrap();
-    db.respond_to_channel_invite(channel, user_c, true)
-        .await
-        .unwrap();
-
-    let owner_id = db.create_server("test").await.unwrap().0 as u32;
-    db.join_channel_chat(channel, rpc::ConnectionId { owner_id, id: 0 }, user_a)
-        .await
-        .unwrap();
-    db.join_channel_chat(channel, rpc::ConnectionId { owner_id, id: 1 }, user_b)
-        .await
-        .unwrap();
-
-    // As user A, create messages that reuse the same nonces. The requests
-    // succeed, but return the same ids.
-    let id1 = db
-        .create_channel_message(
-            channel,
-            user_a,
-            "hi @user_b",
-            &mentions_to_proto(&[(3..10, user_b.to_proto())]),
-            OffsetDateTime::now_utc(),
-            100,
-            None,
-        )
-        .await
-        .unwrap()
-        .message_id;
-    let id2 = db
-        .create_channel_message(
-            channel,
-            user_a,
-            "hello, fellow users",
-            &mentions_to_proto(&[]),
-            OffsetDateTime::now_utc(),
-            200,
-            None,
-        )
-        .await
-        .unwrap()
-        .message_id;
-    let id3 = db
-        .create_channel_message(
-            channel,
-            user_a,
-            "bye @user_c (same nonce as first message)",
-            &mentions_to_proto(&[(4..11, user_c.to_proto())]),
-            OffsetDateTime::now_utc(),
-            100,
-            None,
-        )
-        .await
-        .unwrap()
-        .message_id;
-    let id4 = db
-        .create_channel_message(
-            channel,
-            user_a,
-            "omg (same nonce as second message)",
-            &mentions_to_proto(&[]),
-            OffsetDateTime::now_utc(),
-            200,
-            None,
-        )
-        .await
-        .unwrap()
-        .message_id;
-
-    // As a different user, reuse one of the same nonces. This request succeeds
-    // and returns a different id.
-    let id5 = db
-        .create_channel_message(
-            channel,
-            user_b,
-            "omg @user_a (same nonce as user_a's first message)",
-            &mentions_to_proto(&[(4..11, user_a.to_proto())]),
-            OffsetDateTime::now_utc(),
-            100,
-            None,
-        )
-        .await
-        .unwrap()
-        .message_id;
-
-    assert_ne!(id1, id2);
-    assert_eq!(id1, id3);
-    assert_eq!(id2, id4);
-    assert_ne!(id5, id1);
-
-    let messages = db
-        .get_channel_messages(channel, user_a, 5, None)
-        .await
-        .unwrap()
-        .into_iter()
-        .map(|m| (m.id, m.body, m.mentions))
-        .collect::<Vec<_>>();
-    assert_eq!(
-        messages,
-        &[
-            (
-                id1.to_proto(),
-                "hi @user_b".into(),
-                mentions_to_proto(&[(3..10, user_b.to_proto())]),
-            ),
-            (
-                id2.to_proto(),
-                "hello, fellow users".into(),
-                mentions_to_proto(&[])
-            ),
-            (
-                id5.to_proto(),
-                "omg @user_a (same nonce as user_a's first message)".into(),
-                mentions_to_proto(&[(4..11, user_a.to_proto())]),
-            ),
-        ]
-    );
-}
-
-test_both_dbs!(
-    test_unseen_channel_messages,
-    test_unseen_channel_messages_postgres,
-    test_unseen_channel_messages_sqlite
-);
-
-async fn test_unseen_channel_messages(db: &Arc<Database>) {
-    let user = new_test_user(db, "user_a@example.com").await;
-    let observer = new_test_user(db, "user_b@example.com").await;
-
-    let channel_1 = db.create_root_channel("channel", user).await.unwrap();
-    let channel_2 = db.create_root_channel("channel-2", user).await.unwrap();
-
-    db.invite_channel_member(channel_1, observer, user, ChannelRole::Member)
-        .await
-        .unwrap();
-    db.invite_channel_member(channel_2, observer, user, ChannelRole::Member)
-        .await
-        .unwrap();
-
-    db.respond_to_channel_invite(channel_1, observer, true)
-        .await
-        .unwrap();
-    db.respond_to_channel_invite(channel_2, observer, true)
-        .await
-        .unwrap();
-
-    let owner_id = db.create_server("test").await.unwrap().0 as u32;
-    let user_connection_id = rpc::ConnectionId { owner_id, id: 0 };
-
-    db.join_channel_chat(channel_1, user_connection_id, user)
-        .await
-        .unwrap();
-
-    let _ = db
-        .create_channel_message(
-            channel_1,
-            user,
-            "1_1",
-            &[],
-            OffsetDateTime::now_utc(),
-            1,
-            None,
-        )
-        .await
-        .unwrap();
-
-    let _ = db
-        .create_channel_message(
-            channel_1,
-            user,
-            "1_2",
-            &[],
-            OffsetDateTime::now_utc(),
-            2,
-            None,
-        )
-        .await
-        .unwrap();
-
-    let third_message = db
-        .create_channel_message(
-            channel_1,
-            user,
-            "1_3",
-            &[],
-            OffsetDateTime::now_utc(),
-            3,
-            None,
-        )
-        .await
-        .unwrap()
-        .message_id;
-
-    db.join_channel_chat(channel_2, user_connection_id, user)
-        .await
-        .unwrap();
-
-    let fourth_message = db
-        .create_channel_message(
-            channel_2,
-            user,
-            "2_1",
-            &[],
-            OffsetDateTime::now_utc(),
-            4,
-            None,
-        )
-        .await
-        .unwrap()
-        .message_id;
-
-    // Check that observer has new messages
-    let latest_messages = db
-        .transaction(|tx| async move {
-            db.latest_channel_messages(&[channel_1, channel_2], &tx)
-                .await
-        })
-        .await
-        .unwrap();
-
-    assert_eq!(
-        latest_messages,
-        [
-            rpc::proto::ChannelMessageId {
-                channel_id: channel_1.to_proto(),
-                message_id: third_message.to_proto(),
-            },
-            rpc::proto::ChannelMessageId {
-                channel_id: channel_2.to_proto(),
-                message_id: fourth_message.to_proto(),
-            },
-        ]
-    );
-}
-
-test_both_dbs!(
-    test_channel_message_mentions,
-    test_channel_message_mentions_postgres,
-    test_channel_message_mentions_sqlite
-);
-
-async fn test_channel_message_mentions(db: &Arc<Database>) {
-    let user_a = new_test_user(db, "user_a@example.com").await;
-    let user_b = new_test_user(db, "user_b@example.com").await;
-    let user_c = new_test_user(db, "user_c@example.com").await;
-
-    let channel = db
-        .create_channel("channel", None, user_a)
-        .await
-        .unwrap()
-        .0
-        .id;
-    db.invite_channel_member(channel, user_b, user_a, ChannelRole::Member)
-        .await
-        .unwrap();
-    db.respond_to_channel_invite(channel, user_b, true)
-        .await
-        .unwrap();
-
-    let owner_id = db.create_server("test").await.unwrap().0 as u32;
-    let connection_id = rpc::ConnectionId { owner_id, id: 0 };
-    db.join_channel_chat(channel, connection_id, user_a)
-        .await
-        .unwrap();
-
-    db.create_channel_message(
-        channel,
-        user_a,
-        "hi @user_b and @user_c",
-        &mentions_to_proto(&[(3..10, user_b.to_proto()), (15..22, user_c.to_proto())]),
-        OffsetDateTime::now_utc(),
-        1,
-        None,
-    )
-    .await
-    .unwrap();
-    db.create_channel_message(
-        channel,
-        user_a,
-        "bye @user_c",
-        &mentions_to_proto(&[(4..11, user_c.to_proto())]),
-        OffsetDateTime::now_utc(),
-        2,
-        None,
-    )
-    .await
-    .unwrap();
-    db.create_channel_message(
-        channel,
-        user_a,
-        "umm",
-        &mentions_to_proto(&[]),
-        OffsetDateTime::now_utc(),
-        3,
-        None,
-    )
-    .await
-    .unwrap();
-    db.create_channel_message(
-        channel,
-        user_a,
-        "@user_b, stop.",
-        &mentions_to_proto(&[(0..7, user_b.to_proto())]),
-        OffsetDateTime::now_utc(),
-        4,
-        None,
-    )
-    .await
-    .unwrap();
-
-    let messages = db
-        .get_channel_messages(channel, user_b, 5, None)
-        .await
-        .unwrap()
-        .into_iter()
-        .map(|m| (m.body, m.mentions))
-        .collect::<Vec<_>>();
-    assert_eq!(
-        &messages,
-        &[
-            (
-                "hi @user_b and @user_c".into(),
-                mentions_to_proto(&[(3..10, user_b.to_proto()), (15..22, user_c.to_proto())]),
-            ),
-            (
-                "bye @user_c".into(),
-                mentions_to_proto(&[(4..11, user_c.to_proto())]),
-            ),
-            ("umm".into(), mentions_to_proto(&[]),),
-            (
-                "@user_b, stop.".into(),
-                mentions_to_proto(&[(0..7, user_b.to_proto())]),
-            ),
-        ]
-    );
-}
diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs
index 9e4dfd4854b4de67de522bfbbd1160fe880a05cb..e19c59f9974f243a585b02baac8d87dc82e0d405 100644
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -4,10 +4,9 @@ use crate::api::{CloudflareIpCountryHeader, SystemIdHeader};
 use crate::{
     AppState, Error, Result, auth,
     db::{
-        self, BufferId, Capability, Channel, ChannelId, ChannelRole, ChannelsForUser,
-        CreatedChannelMessage, Database, InviteMemberResult, MembershipUpdated, MessageId,
-        NotificationId, ProjectId, RejoinedProject, RemoveChannelMemberResult,
-        RespondToChannelInvite, RoomId, ServerId, UpdatedChannelMessage, User, UserId,
+        self, BufferId, Capability, Channel, ChannelId, ChannelRole, ChannelsForUser, Database,
+        InviteMemberResult, MembershipUpdated, NotificationId, ProjectId, RejoinedProject,
+        RemoveChannelMemberResult, RespondToChannelInvite, RoomId, ServerId, User, UserId,
     },
     executor::Executor,
 };
@@ -66,7 +65,6 @@ use std::{
     },
     time::{Duration, Instant},
 };
-use time::OffsetDateTime;
 use tokio::sync::{Semaphore, watch};
 use tower::ServiceBuilder;
 use tracing::{
@@ -80,8 +78,6 @@ pub const RECONNECT_TIMEOUT: Duration = Duration::from_secs(30);
 // kubernetes gives terminated pods 10s to shutdown gracefully. After they're gone, we can clean up old resources.
 pub const CLEANUP_TIMEOUT: Duration = Duration::from_secs(15);
 
-const MESSAGE_COUNT_PER_PAGE: usize = 100;
-const MAX_MESSAGE_LEN: usize = 1024;
 const NOTIFICATION_COUNT_PER_PAGE: usize = 50;
 const MAX_CONCURRENT_CONNECTIONS: usize = 512;
 
@@ -3597,235 +3593,36 @@ fn send_notifications(
 
 /// Send a message to the channel
 async fn send_channel_message(
-    request: proto::SendChannelMessage,
-    response: Response<proto::SendChannelMessage>,
-    session: MessageContext,
+    _request: proto::SendChannelMessage,
+    _response: Response<proto::SendChannelMessage>,
+    _session: MessageContext,
 ) -> Result<()> {
-    // Validate the message body.
-    let body = request.body.trim().to_string();
-    if body.len() > MAX_MESSAGE_LEN {
-        return Err(anyhow!("message is too long"))?;
-    }
-    if body.is_empty() {
-        return Err(anyhow!("message can't be blank"))?;
-    }
-
-    // TODO: adjust mentions if body is trimmed
-
-    let timestamp = OffsetDateTime::now_utc();
-    let nonce = request.nonce.context("nonce can't be blank")?;
-
-    let channel_id = ChannelId::from_proto(request.channel_id);
-    let CreatedChannelMessage {
-        message_id,
-        participant_connection_ids,
-        notifications,
-    } = session
-        .db()
-        .await
-        .create_channel_message(
-            channel_id,
-            session.user_id(),
-            &body,
-            &request.mentions,
-            timestamp,
-            nonce.clone().into(),
-            request.reply_to_message_id.map(MessageId::from_proto),
-        )
-        .await?;
-
-    let message = proto::ChannelMessage {
-        sender_id: session.user_id().to_proto(),
-        id: message_id.to_proto(),
-        body,
-        mentions: request.mentions,
-        timestamp: timestamp.unix_timestamp() as u64,
-        nonce: Some(nonce),
-        reply_to_message_id: request.reply_to_message_id,
-        edited_at: None,
-    };
-    broadcast(
-        Some(session.connection_id),
-        participant_connection_ids.clone(),
-        |connection| {
-            session.peer.send(
-                connection,
-                proto::ChannelMessageSent {
-                    channel_id: channel_id.to_proto(),
-                    message: Some(message.clone()),
-                },
-            )
-        },
-    );
-    response.send(proto::SendChannelMessageResponse {
-        message: Some(message),
-    })?;
-
-    let pool = &*session.connection_pool().await;
-    let non_participants =
-        pool.channel_connection_ids(channel_id)
-            .filter_map(|(connection_id, _)| {
-                if participant_connection_ids.contains(&connection_id) {
-                    None
-                } else {
-                    Some(connection_id)
-                }
-            });
-    broadcast(None, non_participants, |peer_id| {
-        session.peer.send(
-            peer_id,
-            proto::UpdateChannels {
-                latest_channel_message_ids: vec![proto::ChannelMessageId {
-                    channel_id: channel_id.to_proto(),
-                    message_id: message_id.to_proto(),
-                }],
-                ..Default::default()
-            },
-        )
-    });
-    send_notifications(pool, &session.peer, notifications);
-
-    Ok(())
+    Err(anyhow!("chat has been removed in the latest version of Zed").into())
 }
 
 /// Delete a channel message
 async fn remove_channel_message(
-    request: proto::RemoveChannelMessage,
-    response: Response<proto::RemoveChannelMessage>,
-    session: MessageContext,
+    _request: proto::RemoveChannelMessage,
+    _response: Response<proto::RemoveChannelMessage>,
+    _session: MessageContext,
 ) -> Result<()> {
-    let channel_id = ChannelId::from_proto(request.channel_id);
-    let message_id = MessageId::from_proto(request.message_id);
-    let (connection_ids, existing_notification_ids) = session
-        .db()
-        .await
-        .remove_channel_message(channel_id, message_id, session.user_id())
-        .await?;
-
-    broadcast(
-        Some(session.connection_id),
-        connection_ids,
-        move |connection| {
-            session.peer.send(connection, request.clone())?;
-
-            for notification_id in &existing_notification_ids {
-                session.peer.send(
-                    connection,
-                    proto::DeleteNotification {
-                        notification_id: (*notification_id).to_proto(),
-                    },
-                )?;
-            }
-
-            Ok(())
-        },
-    );
-    response.send(proto::Ack {})?;
-    Ok(())
+    Err(anyhow!("chat has been removed in the latest version of Zed").into())
 }
 
 async fn update_channel_message(
-    request: proto::UpdateChannelMessage,
-    response: Response<proto::UpdateChannelMessage>,
-    session: MessageContext,
+    _request: proto::UpdateChannelMessage,
+    _response: Response<proto::UpdateChannelMessage>,
+    _session: MessageContext,
 ) -> Result<()> {
-    let channel_id = ChannelId::from_proto(request.channel_id);
-    let message_id = MessageId::from_proto(request.message_id);
-    let updated_at = OffsetDateTime::now_utc();
-    let UpdatedChannelMessage {
-        message_id,
-        participant_connection_ids,
-        notifications,
-        reply_to_message_id,
-        timestamp,
-        deleted_mention_notification_ids,
-        updated_mention_notifications,
-    } = session
-        .db()
-        .await
-        .update_channel_message(
-            channel_id,
-            message_id,
-            session.user_id(),
-            request.body.as_str(),
-            &request.mentions,
-            updated_at,
-        )
-        .await?;
-
-    let nonce = request.nonce.clone().context("nonce can't be blank")?;
-
-    let message = proto::ChannelMessage {
-        sender_id: session.user_id().to_proto(),
-        id: message_id.to_proto(),
-        body: request.body.clone(),
-        mentions: request.mentions.clone(),
-        timestamp: timestamp.assume_utc().unix_timestamp() as u64,
-        nonce: Some(nonce),
-        reply_to_message_id: reply_to_message_id.map(|id| id.to_proto()),
-        edited_at: Some(updated_at.unix_timestamp() as u64),
-    };
-
-    response.send(proto::Ack {})?;
-
-    let pool = &*session.connection_pool().await;
-    broadcast(
-        Some(session.connection_id),
-        participant_connection_ids,
-        |connection| {
-            session.peer.send(
-                connection,
-                proto::ChannelMessageUpdate {
-                    channel_id: channel_id.to_proto(),
-                    message: Some(message.clone()),
-                },
-            )?;
-
-            for notification_id in &deleted_mention_notification_ids {
-                session.peer.send(
-                    connection,
-                    proto::DeleteNotification {
-                        notification_id: (*notification_id).to_proto(),
-                    },
-                )?;
-            }
-
-            for notification in &updated_mention_notifications {
-                session.peer.send(
-                    connection,
-                    proto::UpdateNotification {
-                        notification: Some(notification.clone()),
-                    },
-                )?;
-            }
-
-            Ok(())
-        },
-    );
-
-    send_notifications(pool, &session.peer, notifications);
-
-    Ok(())
+    Err(anyhow!("chat has been removed in the latest version of Zed").into())
 }
 
 /// Mark a channel message as read
 async fn acknowledge_channel_message(
-    request: proto::AckChannelMessage,
-    session: MessageContext,
+    _request: proto::AckChannelMessage,
+    _session: MessageContext,
 ) -> Result<()> {
-    let channel_id = ChannelId::from_proto(request.channel_id);
-    let message_id = MessageId::from_proto(request.message_id);
-    let notifications = session
-        .db()
-        .await
-        .observe_channel_message(channel_id, session.user_id(), message_id)
-        .await?;
-    send_notifications(
-        &*session.connection_pool().await,
-        &session.peer,
-        notifications,
-    );
-    Ok(())
+    Err(anyhow!("chat has been removed in the latest version of Zed").into())
 }
 
 /// Mark a buffer version as synced
@@ -3878,84 +3675,37 @@ async fn get_supermaven_api_key(
 
 /// Start receiving chat updates for a channel
 async fn join_channel_chat(
-    request: proto::JoinChannelChat,
-    response: Response<proto::JoinChannelChat>,
-    session: MessageContext,
+    _request: proto::JoinChannelChat,
+    _response: Response<proto::JoinChannelChat>,
+    _session: MessageContext,
 ) -> Result<()> {
-    let channel_id = ChannelId::from_proto(request.channel_id);
-
-    let db = session.db().await;
-    db.join_channel_chat(channel_id, session.connection_id, session.user_id())
-        .await?;
-    let messages = db
-        .get_channel_messages(channel_id, session.user_id(), MESSAGE_COUNT_PER_PAGE, None)
-        .await?;
-    response.send(proto::JoinChannelChatResponse {
-        done: messages.len() < MESSAGE_COUNT_PER_PAGE,
-        messages,
-    })?;
-    Ok(())
+    Err(anyhow!("chat has been removed in the latest version of Zed").into())
 }
 
 /// Stop receiving chat updates for a channel
 async fn leave_channel_chat(
-    request: proto::LeaveChannelChat,
-    session: MessageContext,
+    _request: proto::LeaveChannelChat,
+    _session: MessageContext,
 ) -> Result<()> {
-    let channel_id = ChannelId::from_proto(request.channel_id);
-    session
-        .db()
-        .await
-        .leave_channel_chat(channel_id, session.connection_id, session.user_id())
-        .await?;
-    Ok(())
+    Err(anyhow!("chat has been removed in the latest version of Zed").into())
 }
 
 /// Retrieve the chat history for a channel
 async fn get_channel_messages(
-    request: proto::GetChannelMessages,
-    response: Response<proto::GetChannelMessages>,
-    session: MessageContext,
+    _request: proto::GetChannelMessages,
+    _response: Response<proto::GetChannelMessages>,
+    _session: MessageContext,
 ) -> Result<()> {
-    let channel_id = ChannelId::from_proto(request.channel_id);
-    let messages = session
-        .db()
-        .await
-        .get_channel_messages(
-            channel_id,
-            session.user_id(),
-            MESSAGE_COUNT_PER_PAGE,
-            Some(MessageId::from_proto(request.before_message_id)),
-        )
-        .await?;
-    response.send(proto::GetChannelMessagesResponse {
-        done: messages.len() < MESSAGE_COUNT_PER_PAGE,
-        messages,
-    })?;
-    Ok(())
+    Err(anyhow!("chat has been removed in the latest version of Zed").into())
 }
 
 /// Retrieve specific chat messages
 async fn get_channel_messages_by_id(
-    request: proto::GetChannelMessagesById,
-    response: Response<proto::GetChannelMessagesById>,
-    session: MessageContext,
+    _request: proto::GetChannelMessagesById,
+    _response: Response<proto::GetChannelMessagesById>,
+    _session: MessageContext,
 ) -> Result<()> {
-    let message_ids = request
-        .message_ids
-        .iter()
-        .map(|id| MessageId::from_proto(*id))
-        .collect::<Vec<_>>();
-    let messages = session
-        .db()
-        .await
-        .get_channel_messages_by_id(session.user_id(), &message_ids)
-        .await?;
-    response.send(proto::GetChannelMessagesResponse {
-        done: messages.len() < MESSAGE_COUNT_PER_PAGE,
-        messages,
-    })?;
-    Ok(())
+    Err(anyhow!("chat has been removed in the latest version of Zed").into())
 }
 
 /// Retrieve the current users notifications
@@ -4095,7 +3845,6 @@ fn build_update_user_channels(channels: &ChannelsForUser) -> proto::UpdateUserCh
             })
             .collect(),
         observed_channel_buffer_version: channels.observed_buffer_versions.clone(),
-        observed_channel_message_id: channels.observed_channel_messages.clone(),
     }
 }
 
@@ -4107,7 +3856,6 @@ fn build_channels_update(channels: ChannelsForUser) -> proto::UpdateChannels {
     }
 
     update.latest_channel_buffer_versions = channels.latest_buffer_versions;
-    update.latest_channel_message_ids = channels.latest_channel_messages;
 
     for (channel_id, participants) in channels.channel_participants {
         update
diff --git a/crates/collab/src/tests.rs b/crates/collab/src/tests.rs
index ddf245b06f322b5c62ba83d56f05fbca65e2ba9d..7d07360b8042ed54a9f19a82a2876e448e8a14a4 100644
--- a/crates/collab/src/tests.rs
+++ b/crates/collab/src/tests.rs
@@ -6,7 +6,6 @@ use gpui::{Entity, TestAppContext};
 
 mod channel_buffer_tests;
 mod channel_guest_tests;
-mod channel_message_tests;
 mod channel_tests;
 mod editor_tests;
 mod following_tests;
diff --git a/crates/collab/src/tests/channel_message_tests.rs b/crates/collab/src/tests/channel_message_tests.rs
deleted file mode 100644
index dbc5cd86c2582719bbb0782e1b3630f08e4cacaf..0000000000000000000000000000000000000000
--- a/crates/collab/src/tests/channel_message_tests.rs
+++ /dev/null
@@ -1,725 +0,0 @@
-use crate::{rpc::RECONNECT_TIMEOUT, tests::TestServer};
-use channel::{ChannelChat, ChannelMessageId, MessageParams};
-use collab_ui::chat_panel::ChatPanel;
-use gpui::{BackgroundExecutor, Entity, TestAppContext};
-use rpc::Notification;
-use workspace::dock::Panel;
-
-#[gpui::test]
-async fn test_basic_channel_messages(
-    executor: BackgroundExecutor,
-    mut cx_a: &mut TestAppContext,
-    mut cx_b: &mut TestAppContext,
-    mut cx_c: &mut TestAppContext,
-) {
-    let mut server = TestServer::start(executor.clone()).await;
-    let client_a = server.create_client(cx_a, "user_a").await;
-    let client_b = server.create_client(cx_b, "user_b").await;
-    let client_c = server.create_client(cx_c, "user_c").await;
-
-    let channel_id = server
-        .make_channel(
-            "the-channel",
-            None,
-            (&client_a, cx_a),
-            &mut [(&client_b, cx_b), (&client_c, cx_c)],
-        )
-        .await;
-
-    let channel_chat_a = client_a
-        .channel_store()
-        .update(cx_a, |store, cx| store.open_channel_chat(channel_id, cx))
-        .await
-        .unwrap();
-    let channel_chat_b = client_b
-        .channel_store()
-        .update(cx_b, |store, cx| store.open_channel_chat(channel_id, cx))
-        .await
-        .unwrap();
-
-    let message_id = channel_chat_a
-        .update(cx_a, |c, cx| {
-            c.send_message(
-                MessageParams {
-                    text: "hi @user_c!".into(),
-                    mentions: vec![(3..10, client_c.id())],
-                    reply_to_message_id: None,
-                },
-                cx,
-            )
-            .unwrap()
-        })
-        .await
-        .unwrap();
-    channel_chat_a
-        .update(cx_a, |c, cx| c.send_message("two".into(), cx).unwrap())
-        .await
-        .unwrap();
-
-    executor.run_until_parked();
-    channel_chat_b
-        .update(cx_b, |c, cx| c.send_message("three".into(), cx).unwrap())
-        .await
-        .unwrap();
-
-    executor.run_until_parked();
-
-    let channel_chat_c = client_c
-        .channel_store()
-        .update(cx_c, |store, cx| store.open_channel_chat(channel_id, cx))
-        .await
-        .unwrap();
-
-    for (chat, cx) in [
-        (&channel_chat_a, &mut cx_a),
-        (&channel_chat_b, &mut cx_b),
-        (&channel_chat_c, &mut cx_c),
-    ] {
-        chat.update(*cx, |c, _| {
-            assert_eq!(
-                c.messages()
-                    .iter()
-                    .map(|m| (m.body.as_str(), m.mentions.as_slice()))
-                    .collect::<Vec<_>>(),
-                vec![
-                    ("hi @user_c!", [(3..10, client_c.id())].as_slice()),
-                    ("two", &[]),
-                    ("three", &[])
-                ],
-                "results for user {}",
-                c.client().id(),
-            );
-        });
-    }
-
-    client_c.notification_store().update(cx_c, |store, _| {
-        assert_eq!(store.notification_count(), 2);
-        assert_eq!(store.unread_notification_count(), 1);
-        assert_eq!(
-            store.notification_at(0).unwrap().notification,
-            Notification::ChannelMessageMention {
-                message_id,
-                sender_id: client_a.id(),
-                channel_id: channel_id.0,
-            }
-        );
-        assert_eq!(
-            store.notification_at(1).unwrap().notification,
-            Notification::ChannelInvitation {
-                channel_id: channel_id.0,
-                channel_name: "the-channel".to_string(),
-                inviter_id: client_a.id()
-            }
-        );
-    });
-}
-
-#[gpui::test]
-async fn test_rejoin_channel_chat(
-    executor: BackgroundExecutor,
-    cx_a: &mut TestAppContext,
-    cx_b: &mut TestAppContext,
-) {
-    let mut server = TestServer::start(executor.clone()).await;
-    let client_a = server.create_client(cx_a, "user_a").await;
-    let client_b = server.create_client(cx_b, "user_b").await;
-
-    let channel_id = server
-        .make_channel(
-            "the-channel",
-            None,
-            (&client_a, cx_a),
-            &mut [(&client_b, cx_b)],
-        )
-        .await;
-
-    let channel_chat_a = client_a
-        .channel_store()
-        .update(cx_a, |store, cx| store.open_channel_chat(channel_id, cx))
-        .await
-        .unwrap();
-    let channel_chat_b = client_b
-        .channel_store()
-        .update(cx_b, |store, cx| store.open_channel_chat(channel_id, cx))
-        .await
-        .unwrap();
-
-    channel_chat_a
-        .update(cx_a, |c, cx| c.send_message("one".into(), cx).unwrap())
-        .await
-        .unwrap();
-    channel_chat_b
-        .update(cx_b, |c, cx| c.send_message("two".into(), cx).unwrap())
-        .await
-        .unwrap();
-
-    server.forbid_connections();
-    server.disconnect_client(client_a.peer_id().unwrap());
-
-    // While client A is disconnected, clients A and B both send new messages.
-    channel_chat_a
-        .update(cx_a, |c, cx| c.send_message("three".into(), cx).unwrap())
-        .await
-        .unwrap_err();
-    channel_chat_a
-        .update(cx_a, |c, cx| c.send_message("four".into(), cx).unwrap())
-        .await
-        .unwrap_err();
-    channel_chat_b
-        .update(cx_b, |c, cx| c.send_message("five".into(), cx).unwrap())
-        .await
-        .unwrap();
-    channel_chat_b
-        .update(cx_b, |c, cx| c.send_message("six".into(), cx).unwrap())
-        .await
-        .unwrap();
-
-    // Client A reconnects.
-    server.allow_connections();
-    executor.advance_clock(RECONNECT_TIMEOUT);
-
-    // Client A fetches the messages that were sent while they were disconnected
-    // and resends their own messages which failed to send.
-    let expected_messages = &["one", "two", "five", "six", "three", "four"];
-    assert_messages(&channel_chat_a, expected_messages, cx_a);
-    assert_messages(&channel_chat_b, expected_messages, cx_b);
-}
-
-#[gpui::test]
-async fn test_remove_channel_message(
-    executor: BackgroundExecutor,
-    cx_a: &mut TestAppContext,
-    cx_b: &mut TestAppContext,
-    cx_c: &mut TestAppContext,
-) {
-    let mut server = TestServer::start(executor.clone()).await;
-    let client_a = server.create_client(cx_a, "user_a").await;
-    let client_b = server.create_client(cx_b, "user_b").await;
-    let client_c = server.create_client(cx_c, "user_c").await;
-
-    let channel_id = server
-        .make_channel(
-            "the-channel",
-            None,
-            (&client_a, cx_a),
-            &mut [(&client_b, cx_b), (&client_c, cx_c)],
-        )
-        .await;
-
-    let channel_chat_a = client_a
-        .channel_store()
-        .update(cx_a, |store, cx| store.open_channel_chat(channel_id, cx))
-        .await
-        .unwrap();
-    let channel_chat_b = client_b
-        .channel_store()
-        .update(cx_b, |store, cx| store.open_channel_chat(channel_id, cx))
-        .await
-        .unwrap();
-
-    // Client A sends some messages.
-    channel_chat_a
-        .update(cx_a, |c, cx| c.send_message("one".into(), cx).unwrap())
-        .await
-        .unwrap();
-    let msg_id_2 = channel_chat_a
-        .update(cx_a, |c, cx| {
-            c.send_message(
-                MessageParams {
-                    text: "two @user_b".to_string(),
-                    mentions: vec![(4..12, client_b.id())],
-                    reply_to_message_id: None,
-                },
-                cx,
-            )
-            .unwrap()
-        })
-        .await
-        .unwrap();
-    channel_chat_a
-        .update(cx_a, |c, cx| c.send_message("three".into(), cx).unwrap())
-        .await
-        .unwrap();
-
-    // Clients A and B see all of the messages.
-    executor.run_until_parked();
-    let expected_messages = &["one", "two @user_b", "three"];
-    assert_messages(&channel_chat_a, expected_messages, cx_a);
-    assert_messages(&channel_chat_b, expected_messages, cx_b);
-
-    // Ensure that client B received a notification for the mention.
-    client_b.notification_store().read_with(cx_b, |store, _| {
-        assert_eq!(store.notification_count(), 2);
-        let entry = store.notification_at(0).unwrap();
-        assert_eq!(
-            entry.notification,
-            Notification::ChannelMessageMention {
-                message_id: msg_id_2,
-                sender_id: client_a.id(),
-                channel_id: channel_id.0,
-            }
-        );
-    });
-
-    // Client A deletes one of their messages.
-    channel_chat_a
-        .update(cx_a, |c, cx| {
-            let ChannelMessageId::Saved(id) = c.message(1).id else {
-                panic!("message not saved")
-            };
-            c.remove_message(id, cx)
-        })
-        .await
-        .unwrap();
-
-    // Client B sees that the message is gone.
-    executor.run_until_parked();
-    let expected_messages = &["one", "three"];
-    assert_messages(&channel_chat_a, expected_messages, cx_a);
-    assert_messages(&channel_chat_b, expected_messages, cx_b);
-
-    // Client C joins the channel chat, and does not see the deleted message.
-    let channel_chat_c = client_c
-        .channel_store()
-        .update(cx_c, |store, cx| store.open_channel_chat(channel_id, cx))
-        .await
-        .unwrap();
-    assert_messages(&channel_chat_c, expected_messages, cx_c);
-
-    // Ensure we remove the notifications when the message is removed
-    client_b.notification_store().read_with(cx_b, |store, _| {
-        // First notification is the channel invitation, second would be the mention
-        // notification, which should now be removed.
-        assert_eq!(store.notification_count(), 1);
-    });
-}
-
-#[track_caller]
-fn assert_messages(chat: &Entity<ChannelChat>, messages: &[&str], cx: &mut TestAppContext) {
-    assert_eq!(
-        chat.read_with(cx, |chat, _| {
-            chat.messages()
-                .iter()
-                .map(|m| m.body.clone())
-                .collect::<Vec<_>>()
-        }),
-        messages
-    );
-}
-
-#[gpui::test]
-async fn test_channel_message_changes(
-    executor: BackgroundExecutor,
-    cx_a: &mut TestAppContext,
-    cx_b: &mut TestAppContext,
-) {
-    let mut server = TestServer::start(executor.clone()).await;
-    let client_a = server.create_client(cx_a, "user_a").await;
-    let client_b = server.create_client(cx_b, "user_b").await;
-
-    let channel_id = server
-        .make_channel(
-            "the-channel",
-            None,
-            (&client_a, cx_a),
-            &mut [(&client_b, cx_b)],
-        )
-        .await;
-
-    // Client A sends a message, client B should see that there is a new message.
-    let channel_chat_a = client_a
-        .channel_store()
-        .update(cx_a, |store, cx| store.open_channel_chat(channel_id, cx))
-        .await
-        .unwrap();
-
-    channel_chat_a
-        .update(cx_a, |c, cx| c.send_message("one".into(), cx).unwrap())
-        .await
-        .unwrap();
-
-    executor.run_until_parked();
-
-    let b_has_messages = cx_b.update(|cx| {
-        client_b
-            .channel_store()
-            .read(cx)
-            .has_new_messages(channel_id)
-    });
-
-    assert!(b_has_messages);
-
-    // Opening the chat should clear the changed flag.
-    cx_b.update(|cx| {
-        collab_ui::init(&client_b.app_state, cx);
-    });
-    let project_b = client_b.build_empty_local_project(cx_b);
-    let (workspace_b, cx_b) = client_b.build_workspace(&project_b, cx_b);
-
-    let chat_panel_b = workspace_b.update_in(cx_b, ChatPanel::new);
-    chat_panel_b
-        .update_in(cx_b, |chat_panel, window, cx| {
-            chat_panel.set_active(true, window, cx);
-            chat_panel.select_channel(channel_id, None, cx)
-        })
-        .await
-        .unwrap();
-
-    executor.run_until_parked();
-
-    let b_has_messages = cx_b.update(|_, cx| {
-        client_b
-            .channel_store()
-            .read(cx)
-            .has_new_messages(channel_id)
-    });
-
-    assert!(!b_has_messages);
-
-    // Sending a message while the chat is open should not change the flag.
-    channel_chat_a
-        .update(cx_a, |c, cx| c.send_message("two".into(), cx).unwrap())
-        .await
-        .unwrap();
-
-    executor.run_until_parked();
-
-    let b_has_messages = cx_b.update(|_, cx| {
-        client_b
-            .channel_store()
-            .read(cx)
-            .has_new_messages(channel_id)
-    });
-
-    assert!(!b_has_messages);
-
-    // Sending a message while the chat is closed should change the flag.
-    chat_panel_b.update_in(cx_b, |chat_panel, window, cx| {
-        chat_panel.set_active(false, window, cx);
-    });
-
-    // Sending a message while the chat is open should not change the flag.
-    channel_chat_a
-        .update(cx_a, |c, cx| c.send_message("three".into(), cx).unwrap())
-        .await
-        .unwrap();
-
-    executor.run_until_parked();
-
-    let b_has_messages = cx_b.update(|_, cx| {
-        client_b
-            .channel_store()
-            .read(cx)
-            .has_new_messages(channel_id)
-    });
-
-    assert!(b_has_messages);
-
-    // Closing the chat should re-enable change tracking
-    cx_b.update(|_, _| drop(chat_panel_b));
-
-    channel_chat_a
-        .update(cx_a, |c, cx| c.send_message("four".into(), cx).unwrap())
-        .await
-        .unwrap();
-
-    executor.run_until_parked();
-
-    let b_has_messages = cx_b.update(|_, cx| {
-        client_b
-            .channel_store()
-            .read(cx)
-            .has_new_messages(channel_id)
-    });
-
-    assert!(b_has_messages);
-}
-
-#[gpui::test]
-async fn test_chat_replies(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
-    let mut server = TestServer::start(cx_a.executor()).await;
-    let client_a = server.create_client(cx_a, "user_a").await;
-    let client_b = server.create_client(cx_b, "user_b").await;
-
-    let channel_id = server
-        .make_channel(
-            "the-channel",
-            None,
-            (&client_a, cx_a),
-            &mut [(&client_b, cx_b)],
-        )
-        .await;
-
-    // Client A sends a message, client B should see that there is a new message.
-    let channel_chat_a = client_a
-        .channel_store()
-        .update(cx_a, |store, cx| store.open_channel_chat(channel_id, cx))
-        .await
-        .unwrap();
-
-    let channel_chat_b = client_b
-        .channel_store()
-        .update(cx_b, |store, cx| store.open_channel_chat(channel_id, cx))
-        .await
-        .unwrap();
-
-    let msg_id = channel_chat_a
-        .update(cx_a, |c, cx| c.send_message("one".into(), cx).unwrap())
-        .await
-        .unwrap();
-
-    cx_a.run_until_parked();
-
-    let reply_id = channel_chat_b
-        .update(cx_b, |c, cx| {
-            c.send_message(
-                MessageParams {
-                    text: "reply".into(),
-                    reply_to_message_id: Some(msg_id),
-                    mentions: Vec::new(),
-                },
-                cx,
-            )
-            .unwrap()
-        })
-        .await
-        .unwrap();
-
-    cx_a.run_until_parked();
-
-    channel_chat_a.update(cx_a, |channel_chat, _| {
-        assert_eq!(
-            channel_chat
-                .find_loaded_message(reply_id)
-                .unwrap()
-                .reply_to_message_id,
-            Some(msg_id),
-        )
-    });
-}
-
-#[gpui::test]
-async fn test_chat_editing(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
-    let mut server = TestServer::start(cx_a.executor()).await;
-    let client_a = server.create_client(cx_a, "user_a").await;
-    let client_b = server.create_client(cx_b, "user_b").await;
-
-    let channel_id = server
-        .make_channel(
-            "the-channel",
-            None,
-            (&client_a, cx_a),
-            &mut [(&client_b, cx_b)],
-        )
-        .await;
-
-    // Client A sends a message, client B should see that there is a new message.
-    let channel_chat_a = client_a
-        .channel_store()
-        .update(cx_a, |store, cx| store.open_channel_chat(channel_id, cx))
-        .await
-        .unwrap();
-
-    let channel_chat_b = client_b
-        .channel_store()
-        .update(cx_b, |store, cx| store.open_channel_chat(channel_id, cx))
-        .await
-        .unwrap();
-
-    let msg_id = channel_chat_a
-        .update(cx_a, |c, cx| {
-            c.send_message(
-                MessageParams {
-                    text: "Initial message".into(),
-                    reply_to_message_id: None,
-                    mentions: Vec::new(),
-                },
-                cx,
-            )
-            .unwrap()
-        })
-        .await
-        .unwrap();
-
-    cx_a.run_until_parked();
-
-    channel_chat_a
-        .update(cx_a, |c, cx| {
-            c.update_message(
-                msg_id,
-                MessageParams {
-                    text: "Updated body".into(),
-                    reply_to_message_id: None,
-                    mentions: Vec::new(),
-                },
-                cx,
-            )
-            .unwrap()
-        })
-        .await
-        .unwrap();
-
-    cx_a.run_until_parked();
-    cx_b.run_until_parked();
-
-    channel_chat_a.update(cx_a, |channel_chat, _| {
-        let update_message = channel_chat.find_loaded_message(msg_id).unwrap();
-
-        assert_eq!(update_message.body, "Updated body");
-        assert_eq!(update_message.mentions, Vec::new());
-    });
-    channel_chat_b.update(cx_b, |channel_chat, _| {
-        let update_message = channel_chat.find_loaded_message(msg_id).unwrap();
-
-        assert_eq!(update_message.body, "Updated body");
-        assert_eq!(update_message.mentions, Vec::new());
-    });
-
-    // test mentions are updated correctly
-
-    client_b.notification_store().read_with(cx_b, |store, _| {
-        assert_eq!(store.notification_count(), 1);
-        let entry = store.notification_at(0).unwrap();
-        assert!(matches!(
-            entry.notification,
-            Notification::ChannelInvitation { .. }
-        ),);
-    });
-
-    channel_chat_a
-        .update(cx_a, |c, cx| {
-            c.update_message(
-                msg_id,
-                MessageParams {
-                    text: "Updated body including a mention for @user_b".into(),
-                    reply_to_message_id: None,
-                    mentions: vec![(37..45, client_b.id())],
-                },
-                cx,
-            )
-            .unwrap()
-        })
-        .await
-        .unwrap();
-
-    cx_a.run_until_parked();
-    cx_b.run_until_parked();
-
-    channel_chat_a.update(cx_a, |channel_chat, _| {
-        assert_eq!(
-            channel_chat.find_loaded_message(msg_id).unwrap().body,
-            "Updated body including a mention for @user_b",
-        )
-    });
-    channel_chat_b.update(cx_b, |channel_chat, _| {
-        assert_eq!(
-            channel_chat.find_loaded_message(msg_id).unwrap().body,
-            "Updated body including a mention for @user_b",
-        )
-    });
-    client_b.notification_store().read_with(cx_b, |store, _| {
-        assert_eq!(store.notification_count(), 2);
-        let entry = store.notification_at(0).unwrap();
-        assert_eq!(
-            entry.notification,
-            Notification::ChannelMessageMention {
-                message_id: msg_id,
-                sender_id: client_a.id(),
-                channel_id: channel_id.0,
-            }
-        );
-    });
-
-    // Test update message and keep the mention and check that the body is updated correctly
-
-    channel_chat_a
-        .update(cx_a, |c, cx| {
-            c.update_message(
-                msg_id,
-                MessageParams {
-                    text: "Updated body v2 including a mention for @user_b".into(),
-                    reply_to_message_id: None,
-                    mentions: vec![(37..45, client_b.id())],
-                },
-                cx,
-            )
-            .unwrap()
-        })
-        .await
-        .unwrap();
-
-    cx_a.run_until_parked();
-    cx_b.run_until_parked();
-
-    channel_chat_a.update(cx_a, |channel_chat, _| {
-        assert_eq!(
-            channel_chat.find_loaded_message(msg_id).unwrap().body,
-            "Updated body v2 including a mention for @user_b",
-        )
-    });
-    channel_chat_b.update(cx_b, |channel_chat, _| {
-        assert_eq!(
-            channel_chat.find_loaded_message(msg_id).unwrap().body,
-            "Updated body v2 including a mention for @user_b",
-        )
-    });
-
-    client_b.notification_store().read_with(cx_b, |store, _| {
-        let message = store.channel_message_for_id(msg_id);
-        assert!(message.is_some());
-        assert_eq!(
-            message.unwrap().body,
-            "Updated body v2 including a mention for @user_b"
-        );
-        assert_eq!(store.notification_count(), 2);
-        let entry = store.notification_at(0).unwrap();
-        assert_eq!(
-            entry.notification,
-            Notification::ChannelMessageMention {
-                message_id: msg_id,
-                sender_id: client_a.id(),
-                channel_id: channel_id.0,
-            }
-        );
-    });
-
-    // If we remove a mention from a message the corresponding mention notification
-    // should also be removed.
-
-    channel_chat_a
-        .update(cx_a, |c, cx| {
-            c.update_message(
-                msg_id,
-                MessageParams {
-                    text: "Updated body without a mention".into(),
-                    reply_to_message_id: None,
-                    mentions: vec![],
-                },
-                cx,
-            )
-            .unwrap()
-        })
-        .await
-        .unwrap();
-
-    cx_a.run_until_parked();
-    cx_b.run_until_parked();
-
-    channel_chat_a.update(cx_a, |channel_chat, _| {
-        assert_eq!(
-            channel_chat.find_loaded_message(msg_id).unwrap().body,
-            "Updated body without a mention",
-        )
-    });
-    channel_chat_b.update(cx_b, |channel_chat, _| {
-        assert_eq!(
-            channel_chat.find_loaded_message(msg_id).unwrap().body,
-            "Updated body without a mention",
-        )
-    });
-    client_b.notification_store().read_with(cx_b, |store, _| {
-        // First notification is the channel invitation, second would be the mention
-        // notification, which should now be removed.
-        assert_eq!(store.notification_count(), 1);
-    });
-}
diff --git a/crates/collab/src/tests/following_tests.rs b/crates/collab/src/tests/following_tests.rs
index 1e0c915bcbe142fe4f86c54907391c9708e9af7a..0a9a69bfca9cdda3fc446ac48e9c63da5e75fe28 100644
--- a/crates/collab/src/tests/following_tests.rs
+++ b/crates/collab/src/tests/following_tests.rs
@@ -2098,7 +2098,7 @@ async fn test_following_after_replacement(cx_a: &mut TestAppContext, cx_b: &mut
     share_workspace(&workspace, cx_a).await.unwrap();
     let buffer = workspace.update(cx_a, |workspace, cx| {
         workspace.project().update(cx, |project, cx| {
-            project.create_local_buffer(&sample_text(26, 5, 'a'), None, cx)
+            project.create_local_buffer(&sample_text(26, 5, 'a'), None, false, cx)
         })
     });
     let multibuffer = cx_a.new(|cx| {
diff --git a/crates/collab/src/tests/integration_tests.rs b/crates/collab/src/tests/integration_tests.rs
index 6bb2db05201ea464053a758b390e84ccdfc6527a..646dbfbd1575756e6955c0d60ae5af64a2760328 100644
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -2506,7 +2506,7 @@ async fn test_propagate_saves_and_fs_changes(
     });
 
     let new_buffer_a = project_a
-        .update(cx_a, |p, cx| p.create_buffer(cx))
+        .update(cx_a, |p, cx| p.create_buffer(false, cx))
         .await
         .unwrap();
 
@@ -5746,7 +5746,7 @@ async fn test_open_buffer_while_getting_definition_pointing_to_it(
 
     let definitions;
     let buffer_b2;
-    if rng.r#gen() {
+    if rng.random() {
         cx_a.run_until_parked();
         cx_b.run_until_parked();
         definitions = project_b.update(cx_b, |p, cx| p.definitions(&buffer_b1, 23, cx));
diff --git a/crates/collab/src/tests/random_channel_buffer_tests.rs b/crates/collab/src/tests/random_channel_buffer_tests.rs
index 6fcd6d75cd0d827296f555bfa54c18dac518a3be..9451090af2198117ddb20241b99be5b208daa729 100644
--- a/crates/collab/src/tests/random_channel_buffer_tests.rs
+++ b/crates/collab/src/tests/random_channel_buffer_tests.rs
@@ -84,7 +84,7 @@ impl RandomizedTest for RandomChannelBufferTest {
         }
 
         loop {
-            match rng.gen_range(0..100_u32) {
+            match rng.random_range(0..100_u32) {
                 0..=29 => {
                     let channel_name = client.channel_store().read_with(cx, |store, cx| {
                         store.ordered_channels().find_map(|(_, channel)| {
diff --git a/crates/collab/src/tests/random_project_collaboration_tests.rs b/crates/collab/src/tests/random_project_collaboration_tests.rs
index bfe05c4a1d600bb280d3821350204d0b2d0d6e08..326f64cb244b88a64728f4347e3cfc31a8c252bf 100644
--- a/crates/collab/src/tests/random_project_collaboration_tests.rs
+++ b/crates/collab/src/tests/random_project_collaboration_tests.rs
@@ -17,7 +17,7 @@ use project::{
     DEFAULT_COMPLETION_CONTEXT, Project, ProjectPath, search::SearchQuery, search::SearchResult,
 };
 use rand::{
-    distributions::{Alphanumeric, DistString},
+    distr::{self, SampleString},
     prelude::*,
 };
 use serde::{Deserialize, Serialize};
@@ -168,19 +168,19 @@ impl RandomizedTest for ProjectCollaborationTest {
     ) -> ClientOperation {
         let call = cx.read(ActiveCall::global);
         loop {
-            match rng.gen_range(0..100_u32) {
+            match rng.random_range(0..100_u32) {
                 // Mutate the call
                 0..=29 => {
                     // Respond to an incoming call
                     if call.read_with(cx, |call, _| call.incoming().borrow().is_some()) {
-                        break if rng.gen_bool(0.7) {
+                        break if rng.random_bool(0.7) {
                             ClientOperation::AcceptIncomingCall
                         } else {
                             ClientOperation::RejectIncomingCall
                         };
                     }
 
-                    match rng.gen_range(0..100_u32) {
+                    match rng.random_range(0..100_u32) {
                         // Invite a contact to the current call
                         0..=70 => {
                             let available_contacts =
@@ -212,7 +212,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                 }
 
                 // Mutate projects
-                30..=59 => match rng.gen_range(0..100_u32) {
+                30..=59 => match rng.random_range(0..100_u32) {
                     // Open a new project
                     0..=70 => {
                         // Open a remote project
@@ -270,7 +270,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                     }
 
                     // Mutate project worktrees
-                    81.. => match rng.gen_range(0..100_u32) {
+                    81.. => match rng.random_range(0..100_u32) {
                         // Add a worktree to a local project
                         0..=50 => {
                             let Some(project) = client.local_projects().choose(rng).cloned() else {
@@ -279,7 +279,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                             let project_root_name = root_name_for_project(&project, cx);
                             let mut paths = client.fs().paths(false);
                             paths.remove(0);
-                            let new_root_path = if paths.is_empty() || rng.r#gen() {
+                            let new_root_path = if paths.is_empty() || rng.random() {
                                 Path::new(path!("/")).join(plan.next_root_dir_name())
                             } else {
                                 paths.choose(rng).unwrap().clone()
@@ -309,7 +309,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                                     .choose(rng)
                             });
                             let Some(worktree) = worktree else { continue };
-                            let is_dir = rng.r#gen::<bool>();
+                            let is_dir = rng.random::<bool>();
                             let mut full_path =
                                 worktree.read_with(cx, |w, _| PathBuf::from(w.root_name()));
                             full_path.push(gen_file_name(rng));
@@ -334,7 +334,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                     let project_root_name = root_name_for_project(&project, cx);
                     let is_local = project.read_with(cx, |project, _| project.is_local());
 
-                    match rng.gen_range(0..100_u32) {
+                    match rng.random_range(0..100_u32) {
                         // Manipulate an existing buffer
                         0..=70 => {
                             let Some(buffer) = client
@@ -349,7 +349,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                             let full_path = buffer
                                 .read_with(cx, |buffer, cx| buffer.file().unwrap().full_path(cx));
 
-                            match rng.gen_range(0..100_u32) {
+                            match rng.random_range(0..100_u32) {
                                 // Close the buffer
                                 0..=15 => {
                                     break ClientOperation::CloseBuffer {
@@ -360,7 +360,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                                 }
                                 // Save the buffer
                                 16..=29 if buffer.read_with(cx, |b, _| b.is_dirty()) => {
-                                    let detach = rng.gen_bool(0.3);
+                                    let detach = rng.random_bool(0.3);
                                     break ClientOperation::SaveBuffer {
                                         project_root_name,
                                         is_local,
@@ -383,17 +383,17 @@ impl RandomizedTest for ProjectCollaborationTest {
                                 _ => {
                                     let offset = buffer.read_with(cx, |buffer, _| {
                                         buffer.clip_offset(
-                                            rng.gen_range(0..=buffer.len()),
+                                            rng.random_range(0..=buffer.len()),
                                             language::Bias::Left,
                                         )
                                     });
-                                    let detach = rng.r#gen();
+                                    let detach = rng.random();
                                     break ClientOperation::RequestLspDataInBuffer {
                                         project_root_name,
                                         full_path,
                                         offset,
                                         is_local,
-                                        kind: match rng.gen_range(0..5_u32) {
+                                        kind: match rng.random_range(0..5_u32) {
                                             0 => LspRequestKind::Rename,
                                             1 => LspRequestKind::Highlights,
                                             2 => LspRequestKind::Definition,
@@ -407,8 +407,8 @@ impl RandomizedTest for ProjectCollaborationTest {
                         }
 
                         71..=80 => {
-                            let query = rng.gen_range('a'..='z').to_string();
-                            let detach = rng.gen_bool(0.3);
+                            let query = rng.random_range('a'..='z').to_string();
+                            let detach = rng.random_bool(0.3);
                             break ClientOperation::SearchProject {
                                 project_root_name,
                                 is_local,
@@ -460,7 +460,7 @@ impl RandomizedTest for ProjectCollaborationTest {
 
                 // Create or update a file or directory
                 96.. => {
-                    let is_dir = rng.r#gen::<bool>();
+                    let is_dir = rng.random::<bool>();
                     let content;
                     let mut path;
                     let dir_paths = client.fs().directories(false);
@@ -470,11 +470,11 @@ impl RandomizedTest for ProjectCollaborationTest {
                         path = dir_paths.choose(rng).unwrap().clone();
                         path.push(gen_file_name(rng));
                     } else {
-                        content = Alphanumeric.sample_string(rng, 16);
+                        content = distr::Alphanumeric.sample_string(rng, 16);
 
                         // Create a new file or overwrite an existing file
                         let file_paths = client.fs().files();
-                        if file_paths.is_empty() || rng.gen_bool(0.5) {
+                        if file_paths.is_empty() || rng.random_bool(0.5) {
                             path = dir_paths.choose(rng).unwrap().clone();
                             path.push(gen_file_name(rng));
                             path.set_extension("rs");
@@ -1090,7 +1090,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                             move |_, cx| {
                                 let background = cx.background_executor();
                                 let mut rng = background.rng();
-                                let count = rng.gen_range::<usize, _>(1..3);
+                                let count = rng.random_range::<usize, _>(1..3);
                                 let files = fs.as_fake().files();
                                 let files = (0..count)
                                     .map(|_| files.choose(&mut rng).unwrap().clone())
@@ -1117,12 +1117,12 @@ impl RandomizedTest for ProjectCollaborationTest {
                                     let background = cx.background_executor();
                                     let mut rng = background.rng();
 
-                                    let highlight_count = rng.gen_range(1..=5);
+                                    let highlight_count = rng.random_range(1..=5);
                                     for _ in 0..highlight_count {
-                                        let start_row = rng.gen_range(0..100);
-                                        let start_column = rng.gen_range(0..100);
-                                        let end_row = rng.gen_range(0..100);
-                                        let end_column = rng.gen_range(0..100);
+                                        let start_row = rng.random_range(0..100);
+                                        let start_column = rng.random_range(0..100);
+                                        let end_row = rng.random_range(0..100);
+                                        let end_column = rng.random_range(0..100);
                                         let start = PointUtf16::new(start_row, start_column);
                                         let end = PointUtf16::new(end_row, end_column);
                                         let range =
@@ -1219,8 +1219,8 @@ impl RandomizedTest for ProjectCollaborationTest {
                                         guest_project.remote_id(),
                                     );
                                     assert_eq!(
-                                        guest_snapshot.entries(false, 0).collect::<Vec<_>>(),
-                                        host_snapshot.entries(false, 0).collect::<Vec<_>>(),
+                                        guest_snapshot.entries(false, 0).map(null_out_entry_size).collect::<Vec<_>>(),
+                                        host_snapshot.entries(false, 0).map(null_out_entry_size).collect::<Vec<_>>(),
                                         "{} has different snapshot than the host for worktree {:?} ({:?}) and project {:?}",
                                         client.username,
                                         host_snapshot.abs_path(),
@@ -1248,6 +1248,18 @@ impl RandomizedTest for ProjectCollaborationTest {
                             );
                         }
                     });
+
+                // A hack to work around a hack in
+                // https://github.com/zed-industries/zed/pull/16696 that wasn't
+                // detected until we upgraded the rng crate. This whole crate is
+                // going away with DeltaDB soon, so we hold our nose and
+                // continue.
+                fn null_out_entry_size(entry: &project::Entry) -> project::Entry {
+                    project::Entry {
+                        size: 0,
+                        ..entry.clone()
+                    }
+                }
             }
 
             let buffers = client.buffers().clone();
@@ -1422,7 +1434,7 @@ fn generate_git_operation(rng: &mut StdRng, client: &TestClient) -> GitOperation
             .filter(|path| path.starts_with(repo_path))
             .collect::<Vec<_>>();
 
-        let count = rng.gen_range(0..=paths.len());
+        let count = rng.random_range(0..=paths.len());
         paths.shuffle(rng);
         paths.truncate(count);
 
@@ -1434,13 +1446,13 @@ fn generate_git_operation(rng: &mut StdRng, client: &TestClient) -> GitOperation
 
     let repo_path = client.fs().directories(false).choose(rng).unwrap().clone();
 
-    match rng.gen_range(0..100_u32) {
+    match rng.random_range(0..100_u32) {
         0..=25 => {
             let file_paths = generate_file_paths(&repo_path, rng, client);
 
             let contents = file_paths
                 .into_iter()
-                .map(|path| (path, Alphanumeric.sample_string(rng, 16)))
+                .map(|path| (path, distr::Alphanumeric.sample_string(rng, 16)))
                 .collect();
 
             GitOperation::WriteGitIndex {
@@ -1449,7 +1461,8 @@ fn generate_git_operation(rng: &mut StdRng, client: &TestClient) -> GitOperation
             }
         }
         26..=63 => {
-            let new_branch = (rng.gen_range(0..10) > 3).then(|| Alphanumeric.sample_string(rng, 8));
+            let new_branch =
+                (rng.random_range(0..10) > 3).then(|| distr::Alphanumeric.sample_string(rng, 8));
 
             GitOperation::WriteGitBranch {
                 repo_path,
@@ -1596,7 +1609,7 @@ fn choose_random_project(client: &TestClient, rng: &mut StdRng) -> Option<Entity
 fn gen_file_name(rng: &mut StdRng) -> String {
     let mut name = String::new();
     for _ in 0..10 {
-        let letter = rng.gen_range('a'..='z');
+        let letter = rng.random_range('a'..='z');
         name.push(letter);
     }
     name
@@ -1604,7 +1617,7 @@ fn gen_file_name(rng: &mut StdRng) -> String {
 
 fn gen_status(rng: &mut StdRng) -> FileStatus {
     fn gen_tracked_status(rng: &mut StdRng) -> TrackedStatus {
-        match rng.gen_range(0..3) {
+        match rng.random_range(0..3) {
             0 => TrackedStatus {
                 index_status: StatusCode::Unmodified,
                 worktree_status: StatusCode::Unmodified,
@@ -1626,7 +1639,7 @@ fn gen_status(rng: &mut StdRng) -> FileStatus {
     }
 
     fn gen_unmerged_status_code(rng: &mut StdRng) -> UnmergedStatusCode {
-        match rng.gen_range(0..3) {
+        match rng.random_range(0..3) {
             0 => UnmergedStatusCode::Updated,
             1 => UnmergedStatusCode::Added,
             2 => UnmergedStatusCode::Deleted,
@@ -1634,7 +1647,7 @@ fn gen_status(rng: &mut StdRng) -> FileStatus {
         }
     }
 
-    match rng.gen_range(0..2) {
+    match rng.random_range(0..2) {
         0 => FileStatus::Unmerged(UnmergedStatus {
             first_head: gen_unmerged_status_code(rng),
             second_head: gen_unmerged_status_code(rng),
diff --git a/crates/collab/src/tests/randomized_test_helpers.rs b/crates/collab/src/tests/randomized_test_helpers.rs
index d6c299a6a9ed4e0439573e9b33fabe8ff122963d..9a372017e34f575f780d56f3936fefec832e160c 100644
--- a/crates/collab/src/tests/randomized_test_helpers.rs
+++ b/crates/collab/src/tests/randomized_test_helpers.rs
@@ -208,9 +208,9 @@ pub fn save_randomized_test_plan() {
 
 impl<T: RandomizedTest> TestPlan<T> {
     pub async fn new(server: &mut TestServer, mut rng: StdRng) -> Arc<Mutex<Self>> {
-        let allow_server_restarts = rng.gen_bool(0.7);
-        let allow_client_reconnection = rng.gen_bool(0.7);
-        let allow_client_disconnection = rng.gen_bool(0.1);
+        let allow_server_restarts = rng.random_bool(0.7);
+        let allow_client_reconnection = rng.random_bool(0.7);
+        let allow_client_disconnection = rng.random_bool(0.1);
 
         let mut users = Vec::new();
         for ix in 0..max_peers() {
@@ -407,7 +407,7 @@ impl<T: RandomizedTest> TestPlan<T> {
         }
 
         Some(loop {
-            break match self.rng.gen_range(0..100) {
+            break match self.rng.random_range(0..100) {
                 0..=29 if clients.len() < self.users.len() => {
                     let user = self
                         .users
@@ -421,13 +421,13 @@ impl<T: RandomizedTest> TestPlan<T> {
                     }
                 }
                 30..=34 if clients.len() > 1 && self.allow_client_disconnection => {
-                    let (client, cx) = &clients[self.rng.gen_range(0..clients.len())];
+                    let (client, cx) = &clients[self.rng.random_range(0..clients.len())];
                     let user_id = client.current_user_id(cx);
                     self.operation_ix += 1;
                     ServerOperation::RemoveConnection { user_id }
                 }
                 35..=39 if clients.len() > 1 && self.allow_client_reconnection => {
-                    let (client, cx) = &clients[self.rng.gen_range(0..clients.len())];
+                    let (client, cx) = &clients[self.rng.random_range(0..clients.len())];
                     let user_id = client.current_user_id(cx);
                     self.operation_ix += 1;
                     ServerOperation::BounceConnection { user_id }
@@ -439,12 +439,12 @@ impl<T: RandomizedTest> TestPlan<T> {
                 _ if !clients.is_empty() => {
                     let count = self
                         .rng
-                        .gen_range(1..10)
+                        .random_range(1..10)
                         .min(self.max_operations - self.operation_ix);
                     let batch_id = util::post_inc(&mut self.next_batch_id);
                     let mut user_ids = (0..count)
                         .map(|_| {
-                            let ix = self.rng.gen_range(0..clients.len());
+                            let ix = self.rng.random_range(0..clients.len());
                             let (client, cx) = &clients[ix];
                             client.current_user_id(cx)
                         })
@@ -453,7 +453,7 @@ impl<T: RandomizedTest> TestPlan<T> {
                     ServerOperation::MutateClients {
                         user_ids,
                         batch_id,
-                        quiesce: self.rng.gen_bool(0.7),
+                        quiesce: self.rng.random_bool(0.7),
                     }
                 }
                 _ => continue,
diff --git a/crates/collab_ui/Cargo.toml b/crates/collab_ui/Cargo.toml
index 46ba3ae49639a77dc1e93d0422290fd333acb3ad..34e40d767ea5a9cab115b4186a642ee234337845 100644
--- a/crates/collab_ui/Cargo.toml
+++ b/crates/collab_ui/Cargo.toml
@@ -37,18 +37,15 @@ client.workspace = true
 collections.workspace = true
 db.workspace = true
 editor.workspace = true
-emojis.workspace = true
 futures.workspace = true
 fuzzy.workspace = true
 gpui.workspace = true
-language.workspace = true
 log.workspace = true
 menu.workspace = true
 notifications.workspace = true
 picker.workspace = true
 project.workspace = true
 release_channel.workspace = true
-rich_text.workspace = true
 rpc.workspace = true
 schemars.workspace = true
 serde.workspace = true
diff --git a/crates/collab_ui/src/chat_panel.rs b/crates/collab_ui/src/chat_panel.rs
deleted file mode 100644
index 8aaf6c0aa21f0b677ec091880fd8be674be1d6fe..0000000000000000000000000000000000000000
--- a/crates/collab_ui/src/chat_panel.rs
+++ /dev/null
@@ -1,1380 +0,0 @@
-use crate::{ChatPanelButton, ChatPanelSettings, collab_panel};
-use anyhow::Result;
-use call::{ActiveCall, room};
-use channel::{ChannelChat, ChannelChatEvent, ChannelMessage, ChannelMessageId, ChannelStore};
-use client::{ChannelId, Client};
-use collections::HashMap;
-use db::kvp::KEY_VALUE_STORE;
-use editor::{Editor, actions};
-use gpui::{
-    Action, App, AsyncWindowContext, ClipboardItem, Context, CursorStyle, DismissEvent, ElementId,
-    Entity, EventEmitter, FocusHandle, Focusable, FontWeight, HighlightStyle, ListOffset,
-    ListScrollEvent, ListState, Render, Stateful, Subscription, Task, WeakEntity, Window, actions,
-    div, list, prelude::*, px,
-};
-use language::LanguageRegistry;
-use menu::Confirm;
-use message_editor::MessageEditor;
-use project::Fs;
-use rich_text::{Highlight, RichText};
-use serde::{Deserialize, Serialize};
-use settings::Settings;
-use std::{sync::Arc, time::Duration};
-use time::{OffsetDateTime, UtcOffset};
-use ui::{
-    Avatar, Button, ContextMenu, IconButton, IconName, KeyBinding, Label, PopoverMenu, Tab, TabBar,
-    Tooltip, prelude::*,
-};
-use util::{ResultExt, TryFutureExt};
-use workspace::{
-    Workspace,
-    dock::{DockPosition, Panel, PanelEvent},
-};
-
-mod message_editor;
-
-const MESSAGE_LOADING_THRESHOLD: usize = 50;
-const CHAT_PANEL_KEY: &str = "ChatPanel";
-
-pub fn init(cx: &mut App) {
-    cx.observe_new(|workspace: &mut Workspace, _, _| {
-        workspace.register_action(|workspace, _: &ToggleFocus, window, cx| {
-            workspace.toggle_panel_focus::<ChatPanel>(window, cx);
-        });
-    })
-    .detach();
-}
-
-pub struct ChatPanel {
-    client: Arc<Client>,
-    channel_store: Entity<ChannelStore>,
-    languages: Arc<LanguageRegistry>,
-    message_list: ListState,
-    active_chat: Option<(Entity<ChannelChat>, Subscription)>,
-    message_editor: Entity<MessageEditor>,
-    local_timezone: UtcOffset,
-    fs: Arc<dyn Fs>,
-    width: Option<Pixels>,
-    active: bool,
-    pending_serialization: Task<Option<()>>,
-    subscriptions: Vec<gpui::Subscription>,
-    is_scrolled_to_bottom: bool,
-    markdown_data: HashMap<ChannelMessageId, RichText>,
-    focus_handle: FocusHandle,
-    open_context_menu: Option<(u64, Subscription)>,
-    highlighted_message: Option<(u64, Task<()>)>,
-    last_acknowledged_message_id: Option<u64>,
-}
-
-#[derive(Serialize, Deserialize)]
-struct SerializedChatPanel {
-    width: Option<Pixels>,
-}
-
-actions!(
-    chat_panel,
-    [
-        /// Toggles focus on the chat panel.
-        ToggleFocus
-    ]
-);
-
-impl ChatPanel {
-    pub fn new(
-        workspace: &mut Workspace,
-        window: &mut Window,
-        cx: &mut Context<Workspace>,
-    ) -> Entity<Self> {
-        let fs = workspace.app_state().fs.clone();
-        let client = workspace.app_state().client.clone();
-        let channel_store = ChannelStore::global(cx);
-        let user_store = workspace.app_state().user_store.clone();
-        let languages = workspace.app_state().languages.clone();
-
-        let input_editor = cx.new(|cx| {
-            MessageEditor::new(
-                languages.clone(),
-                user_store.clone(),
-                None,
-                cx.new(|cx| Editor::auto_height(1, 4, window, cx)),
-                window,
-                cx,
-            )
-        });
-
-        cx.new(|cx| {
-            let message_list = ListState::new(0, gpui::ListAlignment::Bottom, px(1000.));
-
-            message_list.set_scroll_handler(cx.listener(
-                |this: &mut Self, event: &ListScrollEvent, _, cx| {
-                    if event.visible_range.start < MESSAGE_LOADING_THRESHOLD {
-                        this.load_more_messages(cx);
-                    }
-                    this.is_scrolled_to_bottom = !event.is_scrolled;
-                },
-            ));
-
-            let local_offset = chrono::Local::now().offset().local_minus_utc();
-            let mut this = Self {
-                fs,
-                client,
-                channel_store,
-                languages,
-                message_list,
-                active_chat: Default::default(),
-                pending_serialization: Task::ready(None),
-                message_editor: input_editor,
-                local_timezone: UtcOffset::from_whole_seconds(local_offset).unwrap(),
-                subscriptions: Vec::new(),
-                is_scrolled_to_bottom: true,
-                active: false,
-                width: None,
-                markdown_data: Default::default(),
-                focus_handle: cx.focus_handle(),
-                open_context_menu: None,
-                highlighted_message: None,
-                last_acknowledged_message_id: None,
-            };
-
-            if let Some(channel_id) = ActiveCall::global(cx)
-                .read(cx)
-                .room()
-                .and_then(|room| room.read(cx).channel_id())
-            {
-                this.select_channel(channel_id, None, cx)
-                    .detach_and_log_err(cx);
-            }
-
-            this.subscriptions.push(cx.subscribe(
-                &ActiveCall::global(cx),
-                move |this: &mut Self, call, event: &room::Event, cx| match event {
-                    room::Event::RoomJoined { channel_id } => {
-                        if let Some(channel_id) = channel_id {
-                            this.select_channel(*channel_id, None, cx)
-                                .detach_and_log_err(cx);
-
-                            if call
-                                .read(cx)
-                                .room()
-                                .is_some_and(|room| room.read(cx).contains_guests())
-                            {
-                                cx.emit(PanelEvent::Activate)
-                            }
-                        }
-                    }
-                    room::Event::RoomLeft { channel_id } => {
-                        if channel_id == &this.channel_id(cx) {
-                            cx.emit(PanelEvent::Close)
-                        }
-                    }
-                    _ => {}
-                },
-            ));
-
-            this
-        })
-    }
-
-    pub fn channel_id(&self, cx: &App) -> Option<ChannelId> {
-        self.active_chat
-            .as_ref()
-            .map(|(chat, _)| chat.read(cx).channel_id)
-    }
-
-    pub fn is_scrolled_to_bottom(&self) -> bool {
-        self.is_scrolled_to_bottom
-    }
-
-    pub fn active_chat(&self) -> Option<Entity<ChannelChat>> {
-        self.active_chat.as_ref().map(|(chat, _)| chat.clone())
-    }
-
-    pub fn load(
-        workspace: WeakEntity<Workspace>,
-        cx: AsyncWindowContext,
-    ) -> Task<Result<Entity<Self>>> {
-        cx.spawn(async move |cx| {
-            let serialized_panel = if let Some(panel) = cx
-                .background_spawn(async move { KEY_VALUE_STORE.read_kvp(CHAT_PANEL_KEY) })
-                .await
-                .log_err()
-                .flatten()
-            {
-                Some(serde_json::from_str::<SerializedChatPanel>(&panel)?)
-            } else {
-                None
-            };
-
-            workspace.update_in(cx, |workspace, window, cx| {
-                let panel = Self::new(workspace, window, cx);
-                if let Some(serialized_panel) = serialized_panel {
-                    panel.update(cx, |panel, cx| {
-                        panel.width = serialized_panel.width.map(|r| r.round());
-                        cx.notify();
-                    });
-                }
-                panel
-            })
-        })
-    }
-
-    fn serialize(&mut self, cx: &mut Context<Self>) {
-        let width = self.width;
-        self.pending_serialization = cx.background_spawn(
-            async move {
-                KEY_VALUE_STORE
-                    .write_kvp(
-                        CHAT_PANEL_KEY.into(),
-                        serde_json::to_string(&SerializedChatPanel { width })?,
-                    )
-                    .await?;
-                anyhow::Ok(())
-            }
-            .log_err(),
-        );
-    }
-
-    fn set_active_chat(&mut self, chat: Entity<ChannelChat>, cx: &mut Context<Self>) {
-        if self.active_chat.as_ref().map(|e| &e.0) != Some(&chat) {
-            self.markdown_data.clear();
-            self.message_list.reset(chat.read(cx).message_count());
-            self.message_editor.update(cx, |editor, cx| {
-                editor.set_channel_chat(chat.clone(), cx);
-                editor.clear_reply_to_message_id();
-            });
-            let subscription = cx.subscribe(&chat, Self::channel_did_change);
-            self.active_chat = Some((chat, subscription));
-            self.acknowledge_last_message(cx);
-            cx.notify();
-        }
-    }
-
-    fn channel_did_change(
-        &mut self,
-        _: Entity<ChannelChat>,
-        event: &ChannelChatEvent,
-        cx: &mut Context<Self>,
-    ) {
-        match event {
-            ChannelChatEvent::MessagesUpdated {
-                old_range,
-                new_count,
-            } => {
-                self.message_list.splice(old_range.clone(), *new_count);
-                if self.active {
-                    self.acknowledge_last_message(cx);
-                }
-            }
-            ChannelChatEvent::UpdateMessage {
-                message_id,
-                message_ix,
-            } => {
-                self.message_list.splice(*message_ix..*message_ix + 1, 1);
-                self.markdown_data.remove(message_id);
-            }
-            ChannelChatEvent::NewMessage {
-                channel_id,
-                message_id,
-            } => {
-                if !self.active {
-                    self.channel_store.update(cx, |store, cx| {
-                        store.update_latest_message_id(*channel_id, *message_id, cx)
-                    })
-                }
-            }
-        }
-        cx.notify();
-    }
-
-    fn acknowledge_last_message(&mut self, cx: &mut Context<Self>) {
-        if self.active
-            && self.is_scrolled_to_bottom
-            && let Some((chat, _)) = &self.active_chat
-        {
-            if let Some(channel_id) = self.channel_id(cx) {
-                self.last_acknowledged_message_id = self
-                    .channel_store
-                    .read(cx)
-                    .last_acknowledge_message_id(channel_id);
-            }
-
-            chat.update(cx, |chat, cx| {
-                chat.acknowledge_last_message(cx);
-            });
-        }
-    }
-
-    fn render_replied_to_message(
-        &mut self,
-        message_id: Option<ChannelMessageId>,
-        reply_to_message: &Option<ChannelMessage>,
-        cx: &mut Context<Self>,
-    ) -> impl IntoElement {
-        let reply_to_message = match reply_to_message {
-            None => {
-                return div().child(
-                    h_flex()
-                        .text_ui_xs(cx)
-                        .my_0p5()
-                        .px_0p5()
-                        .gap_x_1()
-                        .rounded_sm()
-                        .child(Icon::new(IconName::ReplyArrowRight).color(Color::Muted))
-                        .when(reply_to_message.is_none(), |el| {
-                            el.child(
-                                Label::new("Message has been deleted...")
-                                    .size(LabelSize::XSmall)
-                                    .color(Color::Muted),
-                            )
-                        }),
-                );
-            }
-            Some(val) => val,
-        };
-
-        let user_being_replied_to = reply_to_message.sender.clone();
-        let message_being_replied_to = reply_to_message.clone();
-
-        let message_element_id: ElementId = match message_id {
-            Some(ChannelMessageId::Saved(id)) => ("reply-to-saved-message-container", id).into(),
-            Some(ChannelMessageId::Pending(id)) => {
-                ("reply-to-pending-message-container", id).into()
-            } // This should never happen
-            None => ("composing-reply-container").into(),
-        };
-
-        let current_channel_id = self.channel_id(cx);
-        let reply_to_message_id = reply_to_message.id;
-
-        div().child(
-            h_flex()
-                .id(message_element_id)
-                .text_ui_xs(cx)
-                .my_0p5()
-                .px_0p5()
-                .gap_x_1()
-                .rounded_sm()
-                .overflow_hidden()
-                .hover(|style| style.bg(cx.theme().colors().element_background))
-                .child(Icon::new(IconName::ReplyArrowRight).color(Color::Muted))
-                .child(Avatar::new(user_being_replied_to.avatar_uri.clone()).size(rems(0.7)))
-                .child(
-                    Label::new(format!("@{}", user_being_replied_to.github_login))
-                        .size(LabelSize::XSmall)
-                        .weight(FontWeight::SEMIBOLD)
-                        .color(Color::Muted),
-                )
-                .child(
-                    div().overflow_y_hidden().child(
-                        Label::new(message_being_replied_to.body.replace('\n', " "))
-                            .size(LabelSize::XSmall)
-                            .color(Color::Default),
-                    ),
-                )
-                .cursor(CursorStyle::PointingHand)
-                .tooltip(Tooltip::text("Go to message"))
-                .on_click(cx.listener(move |chat_panel, _, _, cx| {
-                    if let Some(channel_id) = current_channel_id {
-                        chat_panel
-                            .select_channel(channel_id, reply_to_message_id.into(), cx)
-                            .detach_and_log_err(cx)
-                    }
-                })),
-        )
-    }
-
-    fn render_message(
-        &mut self,
-        ix: usize,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> AnyElement {
-        let active_chat = &self.active_chat.as_ref().unwrap().0;
-        let (message, is_continuation_from_previous, is_admin) =
-            active_chat.update(cx, |active_chat, cx| {
-                let is_admin = self
-                    .channel_store
-                    .read(cx)
-                    .is_channel_admin(active_chat.channel_id);
-
-                let last_message = active_chat.message(ix.saturating_sub(1));
-                let this_message = active_chat.message(ix).clone();
-
-                let duration_since_last_message = this_message.timestamp - last_message.timestamp;
-                let is_continuation_from_previous = last_message.sender.id
-                    == this_message.sender.id
-                    && last_message.id != this_message.id
-                    && duration_since_last_message < Duration::from_secs(5 * 60);
-
-                if let ChannelMessageId::Saved(id) = this_message.id
-                    && this_message
-                        .mentions
-                        .iter()
-                        .any(|(_, user_id)| Some(*user_id) == self.client.user_id())
-                {
-                    active_chat.acknowledge_message(id);
-                }
-
-                (this_message, is_continuation_from_previous, is_admin)
-            });
-
-        let _is_pending = message.is_pending();
-
-        let belongs_to_user = Some(message.sender.id) == self.client.user_id();
-        let can_delete_message = belongs_to_user || is_admin;
-        let can_edit_message = belongs_to_user;
-
-        let element_id: ElementId = match message.id {
-            ChannelMessageId::Saved(id) => ("saved-message", id).into(),
-            ChannelMessageId::Pending(id) => ("pending-message", id).into(),
-        };
-
-        let mentioning_you = message
-            .mentions
-            .iter()
-            .any(|m| Some(m.1) == self.client.user_id());
-
-        let message_id = match message.id {
-            ChannelMessageId::Saved(id) => Some(id),
-            ChannelMessageId::Pending(_) => None,
-        };
-
-        let reply_to_message = message
-            .reply_to_message_id
-            .and_then(|id| active_chat.read(cx).find_loaded_message(id))
-            .cloned();
-
-        let replied_to_you =
-            reply_to_message.as_ref().map(|m| m.sender.id) == self.client.user_id();
-
-        let is_highlighted_message = self
-            .highlighted_message
-            .as_ref()
-            .is_some_and(|(id, _)| Some(id) == message_id.as_ref());
-        let background = if is_highlighted_message {
-            cx.theme().status().info_background
-        } else if mentioning_you || replied_to_you {
-            cx.theme().colors().background
-        } else {
-            cx.theme().colors().panel_background
-        };
-
-        let reply_to_message_id = self.message_editor.read(cx).reply_to_message_id();
-
-        v_flex()
-            .w_full()
-            .relative()
-            .group("")
-            .when(!is_continuation_from_previous, |this| this.pt_2())
-            .child(
-                div()
-                    .group("")
-                    .bg(background)
-                    .rounded_sm()
-                    .overflow_hidden()
-                    .px_1p5()
-                    .py_0p5()
-                    .when_some(reply_to_message_id, |el, reply_id| {
-                        el.when_some(message_id, |el, message_id| {
-                            el.when(reply_id == message_id, |el| {
-                                el.bg(cx.theme().colors().element_selected)
-                            })
-                        })
-                    })
-                    .when(!self.has_open_menu(message_id), |this| {
-                        this.hover(|style| style.bg(cx.theme().colors().element_hover))
-                    })
-                    .when(message.reply_to_message_id.is_some(), |el| {
-                        el.child(self.render_replied_to_message(
-                            Some(message.id),
-                            &reply_to_message,
-                            cx,
-                        ))
-                        .when(is_continuation_from_previous, |this| this.mt_2())
-                    })
-                    .when(
-                        !is_continuation_from_previous || message.reply_to_message_id.is_some(),
-                        |this| {
-                            this.child(
-                                h_flex()
-                                    .gap_2()
-                                    .text_ui_sm(cx)
-                                    .child(
-                                        Avatar::new(message.sender.avatar_uri.clone())
-                                            .size(rems(1.)),
-                                    )
-                                    .child(
-                                        Label::new(message.sender.github_login.clone())
-                                            .size(LabelSize::Small)
-                                            .weight(FontWeight::BOLD),
-                                    )
-                                    .child(
-                                        Label::new(time_format::format_localized_timestamp(
-                                            message.timestamp,
-                                            OffsetDateTime::now_utc(),
-                                            self.local_timezone,
-                                            time_format::TimestampFormat::EnhancedAbsolute,
-                                        ))
-                                        .size(LabelSize::Small)
-                                        .color(Color::Muted),
-                                    ),
-                            )
-                        },
-                    )
-                    .when(mentioning_you || replied_to_you, |this| this.my_0p5())
-                    .map(|el| {
-                        let text = self.markdown_data.entry(message.id).or_insert_with(|| {
-                            Self::render_markdown_with_mentions(
-                                &self.languages,
-                                self.client.id(),
-                                &message,
-                                self.local_timezone,
-                                cx,
-                            )
-                        });
-                        el.child(
-                            v_flex()
-                                .w_full()
-                                .text_ui_sm(cx)
-                                .id(element_id)
-                                .child(text.element("body".into(), window, cx)),
-                        )
-                        .when(self.has_open_menu(message_id), |el| {
-                            el.bg(cx.theme().colors().element_selected)
-                        })
-                    }),
-            )
-            .when(
-                self.last_acknowledged_message_id
-                    .is_some_and(|l| Some(l) == message_id),
-                |this| {
-                    this.child(
-                        h_flex()
-                            .py_2()
-                            .gap_1()
-                            .items_center()
-                            .child(div().w_full().h_0p5().bg(cx.theme().colors().border))
-                            .child(
-                                div()
-                                    .px_1()
-                                    .rounded_sm()
-                                    .text_ui_xs(cx)
-                                    .bg(cx.theme().colors().background)
-                                    .child("New messages"),
-                            )
-                            .child(div().w_full().h_0p5().bg(cx.theme().colors().border)),
-                    )
-                },
-            )
-            .child(
-                self.render_popover_buttons(message_id, can_delete_message, can_edit_message, cx)
-                    .mt_neg_2p5(),
-            )
-            .into_any_element()
-    }
-
-    fn has_open_menu(&self, message_id: Option<u64>) -> bool {
-        match self.open_context_menu.as_ref() {
-            Some((id, _)) => Some(*id) == message_id,
-            None => false,
-        }
-    }
-
-    fn render_popover_button(&self, cx: &mut Context<Self>, child: Stateful<Div>) -> Div {
-        div()
-            .w_6()
-            .bg(cx.theme().colors().element_background)
-            .hover(|style| style.bg(cx.theme().colors().element_hover).rounded_sm())
-            .child(child)
-    }
-
-    fn render_popover_buttons(
-        &self,
-        message_id: Option<u64>,
-        can_delete_message: bool,
-        can_edit_message: bool,
-        cx: &mut Context<Self>,
-    ) -> Div {
-        h_flex()
-            .absolute()
-            .right_2()
-            .overflow_hidden()
-            .rounded_sm()
-            .border_color(cx.theme().colors().element_selected)
-            .border_1()
-            .when(!self.has_open_menu(message_id), |el| {
-                el.visible_on_hover("")
-            })
-            .bg(cx.theme().colors().element_background)
-            .when_some(message_id, |el, message_id| {
-                el.child(
-                    self.render_popover_button(
-                        cx,
-                        div()
-                            .id("reply")
-                            .child(
-                                IconButton::new(("reply", message_id), IconName::ReplyArrowRight)
-                                    .on_click(cx.listener(move |this, _, window, cx| {
-                                        this.cancel_edit_message(cx);
-
-                                        this.message_editor.update(cx, |editor, cx| {
-                                            editor.set_reply_to_message_id(message_id);
-                                            window.focus(&editor.focus_handle(cx));
-                                        })
-                                    })),
-                            )
-                            .tooltip(Tooltip::text("Reply")),
-                    ),
-                )
-            })
-            .when_some(message_id, |el, message_id| {
-                el.when(can_edit_message, |el| {
-                    el.child(
-                        self.render_popover_button(
-                            cx,
-                            div()
-                                .id("edit")
-                                .child(
-                                    IconButton::new(("edit", message_id), IconName::Pencil)
-                                        .on_click(cx.listener(move |this, _, window, cx| {
-                                            this.message_editor.update(cx, |editor, cx| {
-                                                editor.clear_reply_to_message_id();
-
-                                                let message = this
-                                                    .active_chat()
-                                                    .and_then(|active_chat| {
-                                                        active_chat
-                                                            .read(cx)
-                                                            .find_loaded_message(message_id)
-                                                    })
-                                                    .cloned();
-
-                                                if let Some(message) = message {
-                                                    let buffer = editor
-                                                        .editor
-                                                        .read(cx)
-                                                        .buffer()
-                                                        .read(cx)
-                                                        .as_singleton()
-                                                        .expect("message editor must be singleton");
-
-                                                    buffer.update(cx, |buffer, cx| {
-                                                        buffer.set_text(message.body.clone(), cx)
-                                                    });
-
-                                                    editor.set_edit_message_id(message_id);
-                                                    editor.focus_handle(cx).focus(window);
-                                                }
-                                            })
-                                        })),
-                                )
-                                .tooltip(Tooltip::text("Edit")),
-                        ),
-                    )
-                })
-            })
-            .when_some(message_id, |el, message_id| {
-                let this = cx.entity();
-
-                el.child(
-                    self.render_popover_button(
-                        cx,
-                        div()
-                            .child(
-                                PopoverMenu::new(("menu", message_id))
-                                    .trigger(IconButton::new(
-                                        ("trigger", message_id),
-                                        IconName::Ellipsis,
-                                    ))
-                                    .menu(move |window, cx| {
-                                        Some(Self::render_message_menu(
-                                            &this,
-                                            message_id,
-                                            can_delete_message,
-                                            window,
-                                            cx,
-                                        ))
-                                    }),
-                            )
-                            .id("more")
-                            .tooltip(Tooltip::text("More")),
-                    ),
-                )
-            })
-    }
-
-    fn render_message_menu(
-        this: &Entity<Self>,
-        message_id: u64,
-        can_delete_message: bool,
-        window: &mut Window,
-        cx: &mut App,
-    ) -> Entity<ContextMenu> {
-        let menu = {
-            ContextMenu::build(window, cx, move |menu, window, _| {
-                menu.entry(
-                    "Copy message text",
-                    None,
-                    window.handler_for(this, move |this, _, cx| {
-                        if let Some(message) = this.active_chat().and_then(|active_chat| {
-                            active_chat.read(cx).find_loaded_message(message_id)
-                        }) {
-                            let text = message.body.clone();
-                            cx.write_to_clipboard(ClipboardItem::new_string(text))
-                        }
-                    }),
-                )
-                .when(can_delete_message, |menu| {
-                    menu.entry(
-                        "Delete message",
-                        None,
-                        window.handler_for(this, move |this, _, cx| {
-                            this.remove_message(message_id, cx)
-                        }),
-                    )
-                })
-            })
-        };
-        this.update(cx, |this, cx| {
-            let subscription = cx.subscribe_in(
-                &menu,
-                window,
-                |this: &mut Self, _, _: &DismissEvent, _, _| {
-                    this.open_context_menu = None;
-                },
-            );
-            this.open_context_menu = Some((message_id, subscription));
-        });
-        menu
-    }
-
-    fn render_markdown_with_mentions(
-        language_registry: &Arc<LanguageRegistry>,
-        current_user_id: u64,
-        message: &channel::ChannelMessage,
-        local_timezone: UtcOffset,
-        cx: &App,
-    ) -> RichText {
-        let mentions = message
-            .mentions
-            .iter()
-            .map(|(range, user_id)| rich_text::Mention {
-                range: range.clone(),
-                is_self_mention: *user_id == current_user_id,
-            })
-            .collect::<Vec<_>>();
-
-        const MESSAGE_EDITED: &str = " (edited)";
-
-        let mut body = message.body.clone();
-
-        if message.edited_at.is_some() {
-            body.push_str(MESSAGE_EDITED);
-        }
-
-        let mut rich_text = RichText::new(body, &mentions, language_registry);
-
-        if message.edited_at.is_some() {
-            let range = (rich_text.text.len() - MESSAGE_EDITED.len())..rich_text.text.len();
-            rich_text.highlights.push((
-                range.clone(),
-                Highlight::Highlight(HighlightStyle {
-                    color: Some(cx.theme().colors().text_muted),
-                    ..Default::default()
-                }),
-            ));
-
-            if let Some(edit_timestamp) = message.edited_at {
-                let edit_timestamp_text = time_format::format_localized_timestamp(
-                    edit_timestamp,
-                    OffsetDateTime::now_utc(),
-                    local_timezone,
-                    time_format::TimestampFormat::Absolute,
-                );
-
-                rich_text.custom_ranges.push(range);
-                rich_text.set_tooltip_builder_for_custom_ranges(move |_, _, _, cx| {
-                    Some(Tooltip::simple(edit_timestamp_text.clone(), cx))
-                })
-            }
-        }
-        rich_text
-    }
-
-    fn send(&mut self, _: &Confirm, window: &mut Window, cx: &mut Context<Self>) {
-        if let Some((chat, _)) = self.active_chat.as_ref() {
-            let message = self
-                .message_editor
-                .update(cx, |editor, cx| editor.take_message(window, cx));
-
-            if let Some(id) = self.message_editor.read(cx).edit_message_id() {
-                self.message_editor.update(cx, |editor, _| {
-                    editor.clear_edit_message_id();
-                });
-
-                if let Some(task) = chat
-                    .update(cx, |chat, cx| chat.update_message(id, message, cx))
-                    .log_err()
-                {
-                    task.detach();
-                }
-            } else if let Some(task) = chat
-                .update(cx, |chat, cx| chat.send_message(message, cx))
-                .log_err()
-            {
-                task.detach();
-            }
-        }
-    }
-
-    fn remove_message(&mut self, id: u64, cx: &mut Context<Self>) {
-        if let Some((chat, _)) = self.active_chat.as_ref() {
-            chat.update(cx, |chat, cx| chat.remove_message(id, cx).detach())
-        }
-    }
-
-    fn load_more_messages(&mut self, cx: &mut Context<Self>) {
-        if let Some((chat, _)) = self.active_chat.as_ref() {
-            chat.update(cx, |channel, cx| {
-                if let Some(task) = channel.load_more_messages(cx) {
-                    task.detach();
-                }
-            })
-        }
-    }
-
-    pub fn select_channel(
-        &mut self,
-        selected_channel_id: ChannelId,
-        scroll_to_message_id: Option<u64>,
-        cx: &mut Context<ChatPanel>,
-    ) -> Task<Result<()>> {
-        let open_chat = self
-            .active_chat
-            .as_ref()
-            .and_then(|(chat, _)| {
-                (chat.read(cx).channel_id == selected_channel_id)
-                    .then(|| Task::ready(anyhow::Ok(chat.clone())))
-            })
-            .unwrap_or_else(|| {
-                self.channel_store.update(cx, |store, cx| {
-                    store.open_channel_chat(selected_channel_id, cx)
-                })
-            });
-
-        cx.spawn(async move |this, cx| {
-            let chat = open_chat.await?;
-            let highlight_message_id = scroll_to_message_id;
-            let scroll_to_message_id = this.update(cx, |this, cx| {
-                this.set_active_chat(chat.clone(), cx);
-
-                scroll_to_message_id.or(this.last_acknowledged_message_id)
-            })?;
-
-            if let Some(message_id) = scroll_to_message_id
-                && let Some(item_ix) =
-                    ChannelChat::load_history_since_message(chat.clone(), message_id, cx.clone())
-                        .await
-            {
-                this.update(cx, |this, cx| {
-                    if let Some(highlight_message_id) = highlight_message_id {
-                        let task = cx.spawn(async move |this, cx| {
-                            cx.background_executor().timer(Duration::from_secs(2)).await;
-                            this.update(cx, |this, cx| {
-                                this.highlighted_message.take();
-                                cx.notify();
-                            })
-                            .ok();
-                        });
-
-                        this.highlighted_message = Some((highlight_message_id, task));
-                    }
-
-                    if this.active_chat.as_ref().is_some_and(|(c, _)| *c == chat) {
-                        this.message_list.scroll_to(ListOffset {
-                            item_ix,
-                            offset_in_item: px(0.0),
-                        });
-                        cx.notify();
-                    }
-                })?;
-            }
-
-            Ok(())
-        })
-    }
-
-    fn close_reply_preview(&mut self, cx: &mut Context<Self>) {
-        self.message_editor
-            .update(cx, |editor, _| editor.clear_reply_to_message_id());
-    }
-
-    fn cancel_edit_message(&mut self, cx: &mut Context<Self>) {
-        self.message_editor.update(cx, |editor, cx| {
-            // only clear the editor input if we were editing a message
-            if editor.edit_message_id().is_none() {
-                return;
-            }
-
-            editor.clear_edit_message_id();
-
-            let buffer = editor
-                .editor
-                .read(cx)
-                .buffer()
-                .read(cx)
-                .as_singleton()
-                .expect("message editor must be singleton");
-
-            buffer.update(cx, |buffer, cx| buffer.set_text("", cx));
-        });
-    }
-}
-
-impl Render for ChatPanel {
-    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let channel_id = self
-            .active_chat
-            .as_ref()
-            .map(|(c, _)| c.read(cx).channel_id);
-        let message_editor = self.message_editor.read(cx);
-
-        let reply_to_message_id = message_editor.reply_to_message_id();
-        let edit_message_id = message_editor.edit_message_id();
-
-        v_flex()
-            .key_context("ChatPanel")
-            .track_focus(&self.focus_handle)
-            .size_full()
-            .on_action(cx.listener(Self::send))
-            .child(
-                h_flex().child(
-                    TabBar::new("chat_header").child(
-                        h_flex()
-                            .w_full()
-                            .h(Tab::container_height(cx))
-                            .px_2()
-                            .child(Label::new(
-                                self.active_chat
-                                    .as_ref()
-                                    .and_then(|c| {
-                                        Some(format!("#{}", c.0.read(cx).channel(cx)?.name))
-                                    })
-                                    .unwrap_or("Chat".to_string()),
-                            )),
-                    ),
-                ),
-            )
-            .child(div().flex_grow().px_2().map(|this| {
-                if self.active_chat.is_some() {
-                    this.child(
-                        list(
-                            self.message_list.clone(),
-                            cx.processor(Self::render_message),
-                        )
-                        .size_full(),
-                    )
-                } else {
-                    this.child(
-                        div()
-                            .size_full()
-                            .p_4()
-                            .child(
-                                Label::new("Select a channel to chat in.")
-                                    .size(LabelSize::Small)
-                                    .color(Color::Muted),
-                            )
-                            .child(
-                                div().pt_1().w_full().items_center().child(
-                                    Button::new("toggle-collab", "Open")
-                                        .full_width()
-                                        .key_binding(KeyBinding::for_action(
-                                            &collab_panel::ToggleFocus,
-                                            window,
-                                            cx,
-                                        ))
-                                        .on_click(|_, window, cx| {
-                                            window.dispatch_action(
-                                                collab_panel::ToggleFocus.boxed_clone(),
-                                                cx,
-                                            )
-                                        }),
-                                ),
-                            ),
-                    )
-                }
-            }))
-            .when(!self.is_scrolled_to_bottom, |el| {
-                el.child(div().border_t_1().border_color(cx.theme().colors().border))
-            })
-            .when_some(edit_message_id, |el, _| {
-                el.child(
-                    h_flex()
-                        .px_2()
-                        .text_ui_xs(cx)
-                        .justify_between()
-                        .border_t_1()
-                        .border_color(cx.theme().colors().border)
-                        .bg(cx.theme().colors().background)
-                        .child("Editing message")
-                        .child(
-                            IconButton::new("cancel-edit-message", IconName::Close)
-                                .shape(ui::IconButtonShape::Square)
-                                .tooltip(Tooltip::text("Cancel edit message"))
-                                .on_click(cx.listener(move |this, _, _, cx| {
-                                    this.cancel_edit_message(cx);
-                                })),
-                        ),
-                )
-            })
-            .when_some(reply_to_message_id, |el, reply_to_message_id| {
-                let reply_message = self
-                    .active_chat()
-                    .and_then(|active_chat| {
-                        active_chat
-                            .read(cx)
-                            .find_loaded_message(reply_to_message_id)
-                    })
-                    .cloned();
-
-                el.when_some(reply_message, |el, reply_message| {
-                    let user_being_replied_to = reply_message.sender;
-
-                    el.child(
-                        h_flex()
-                            .when(!self.is_scrolled_to_bottom, |el| {
-                                el.border_t_1().border_color(cx.theme().colors().border)
-                            })
-                            .justify_between()
-                            .overflow_hidden()
-                            .items_start()
-                            .py_1()
-                            .px_2()
-                            .bg(cx.theme().colors().background)
-                            .child(
-                                div().flex_shrink().overflow_hidden().child(
-                                    h_flex()
-                                        .id(("reply-preview", reply_to_message_id))
-                                        .child(Label::new("Replying to ").size(LabelSize::Small))
-                                        .child(
-                                            Label::new(format!(
-                                                "@{}",
-                                                user_being_replied_to.github_login
-                                            ))
-                                            .size(LabelSize::Small)
-                                            .weight(FontWeight::BOLD),
-                                        )
-                                        .when_some(channel_id, |this, channel_id| {
-                                            this.cursor_pointer().on_click(cx.listener(
-                                                move |chat_panel, _, _, cx| {
-                                                    chat_panel
-                                                        .select_channel(
-                                                            channel_id,
-                                                            reply_to_message_id.into(),
-                                                            cx,
-                                                        )
-                                                        .detach_and_log_err(cx)
-                                                },
-                                            ))
-                                        }),
-                                ),
-                            )
-                            .child(
-                                IconButton::new("close-reply-preview", IconName::Close)
-                                    .shape(ui::IconButtonShape::Square)
-                                    .tooltip(Tooltip::text("Close reply"))
-                                    .on_click(cx.listener(move |this, _, _, cx| {
-                                        this.close_reply_preview(cx);
-                                    })),
-                            ),
-                    )
-                })
-            })
-            .children(
-                Some(
-                    h_flex()
-                        .p_2()
-                        .on_action(cx.listener(|this, _: &actions::Cancel, _, cx| {
-                            this.cancel_edit_message(cx);
-                            this.close_reply_preview(cx);
-                        }))
-                        .map(|el| el.child(self.message_editor.clone())),
-                )
-                .filter(|_| self.active_chat.is_some()),
-            )
-            .into_any()
-    }
-}
-
-impl Focusable for ChatPanel {
-    fn focus_handle(&self, cx: &App) -> gpui::FocusHandle {
-        if self.active_chat.is_some() {
-            self.message_editor.read(cx).focus_handle(cx)
-        } else {
-            self.focus_handle.clone()
-        }
-    }
-}
-
-impl Panel for ChatPanel {
-    fn position(&self, _: &Window, cx: &App) -> DockPosition {
-        ChatPanelSettings::get_global(cx).dock
-    }
-
-    fn position_is_valid(&self, position: DockPosition) -> bool {
-        matches!(position, DockPosition::Left | DockPosition::Right)
-    }
-
-    fn set_position(&mut self, position: DockPosition, _: &mut Window, cx: &mut Context<Self>) {
-        settings::update_settings_file::<ChatPanelSettings>(
-            self.fs.clone(),
-            cx,
-            move |settings, _| settings.dock = Some(position),
-        );
-    }
-
-    fn size(&self, _: &Window, cx: &App) -> Pixels {
-        self.width
-            .unwrap_or_else(|| ChatPanelSettings::get_global(cx).default_width)
-    }
-
-    fn set_size(&mut self, size: Option<Pixels>, _: &mut Window, cx: &mut Context<Self>) {
-        self.width = size;
-        self.serialize(cx);
-        cx.notify();
-    }
-
-    fn set_active(&mut self, active: bool, _: &mut Window, cx: &mut Context<Self>) {
-        self.active = active;
-        if active {
-            self.acknowledge_last_message(cx);
-        }
-    }
-
-    fn persistent_name() -> &'static str {
-        "ChatPanel"
-    }
-
-    fn icon(&self, _window: &Window, cx: &App) -> Option<ui::IconName> {
-        self.enabled(cx).then(|| ui::IconName::Chat)
-    }
-
-    fn icon_tooltip(&self, _: &Window, _: &App) -> Option<&'static str> {
-        Some("Chat Panel")
-    }
-
-    fn toggle_action(&self) -> Box<dyn gpui::Action> {
-        Box::new(ToggleFocus)
-    }
-
-    fn starts_open(&self, _: &Window, cx: &App) -> bool {
-        ActiveCall::global(cx)
-            .read(cx)
-            .room()
-            .is_some_and(|room| room.read(cx).contains_guests())
-    }
-
-    fn activation_priority(&self) -> u32 {
-        7
-    }
-
-    fn enabled(&self, cx: &App) -> bool {
-        match ChatPanelSettings::get_global(cx).button {
-            ChatPanelButton::Never => false,
-            ChatPanelButton::Always => true,
-            ChatPanelButton::WhenInCall => {
-                let is_in_call = ActiveCall::global(cx)
-                    .read(cx)
-                    .room()
-                    .is_some_and(|room| room.read(cx).contains_guests());
-
-                self.active || is_in_call
-            }
-        }
-    }
-}
-
-impl EventEmitter<PanelEvent> for ChatPanel {}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use gpui::HighlightStyle;
-    use pretty_assertions::assert_eq;
-    use rich_text::Highlight;
-    use time::OffsetDateTime;
-    use util::test::marked_text_ranges;
-
-    #[gpui::test]
-    fn test_render_markdown_with_mentions(cx: &mut App) {
-        let language_registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
-        let (body, ranges) = marked_text_ranges("*hi*, «@abc», let's **call** «@fgh»", false);
-        let message = channel::ChannelMessage {
-            id: ChannelMessageId::Saved(0),
-            body,
-            timestamp: OffsetDateTime::now_utc(),
-            sender: Arc::new(client::User {
-                github_login: "fgh".into(),
-                avatar_uri: "avatar_fgh".into(),
-                id: 103,
-                name: None,
-            }),
-            nonce: 5,
-            mentions: vec![(ranges[0].clone(), 101), (ranges[1].clone(), 102)],
-            reply_to_message_id: None,
-            edited_at: None,
-        };
-
-        let message = ChatPanel::render_markdown_with_mentions(
-            &language_registry,
-            102,
-            &message,
-            UtcOffset::UTC,
-            cx,
-        );
-
-        // Note that the "'" was replaced with ’ due to smart punctuation.
-        let (body, ranges) = marked_text_ranges("«hi», «@abc», let’s «call» «@fgh»", false);
-        assert_eq!(message.text, body);
-        assert_eq!(
-            message.highlights,
-            vec![
-                (
-                    ranges[0].clone(),
-                    HighlightStyle {
-                        font_style: Some(gpui::FontStyle::Italic),
-                        ..Default::default()
-                    }
-                    .into()
-                ),
-                (ranges[1].clone(), Highlight::Mention),
-                (
-                    ranges[2].clone(),
-                    HighlightStyle {
-                        font_weight: Some(gpui::FontWeight::BOLD),
-                        ..Default::default()
-                    }
-                    .into()
-                ),
-                (ranges[3].clone(), Highlight::SelfMention)
-            ]
-        );
-    }
-
-    #[gpui::test]
-    fn test_render_markdown_with_auto_detect_links(cx: &mut App) {
-        let language_registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
-        let message = channel::ChannelMessage {
-            id: ChannelMessageId::Saved(0),
-            body: "Here is a link https://zed.dev to zeds website".to_string(),
-            timestamp: OffsetDateTime::now_utc(),
-            sender: Arc::new(client::User {
-                github_login: "fgh".into(),
-                avatar_uri: "avatar_fgh".into(),
-                id: 103,
-                name: None,
-            }),
-            nonce: 5,
-            mentions: Vec::new(),
-            reply_to_message_id: None,
-            edited_at: None,
-        };
-
-        let message = ChatPanel::render_markdown_with_mentions(
-            &language_registry,
-            102,
-            &message,
-            UtcOffset::UTC,
-            cx,
-        );
-
-        // Note that the "'" was replaced with ’ due to smart punctuation.
-        let (body, ranges) =
-            marked_text_ranges("Here is a link «https://zed.dev» to zeds website", false);
-        assert_eq!(message.text, body);
-        assert_eq!(1, ranges.len());
-        assert_eq!(
-            message.highlights,
-            vec![(
-                ranges[0].clone(),
-                HighlightStyle {
-                    underline: Some(gpui::UnderlineStyle {
-                        thickness: 1.0.into(),
-                        ..Default::default()
-                    }),
-                    ..Default::default()
-                }
-                .into()
-            ),]
-        );
-    }
-
-    #[gpui::test]
-    fn test_render_markdown_with_auto_detect_links_and_additional_formatting(cx: &mut App) {
-        let language_registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
-        let message = channel::ChannelMessage {
-            id: ChannelMessageId::Saved(0),
-            body: "**Here is a link https://zed.dev to zeds website**".to_string(),
-            timestamp: OffsetDateTime::now_utc(),
-            sender: Arc::new(client::User {
-                github_login: "fgh".into(),
-                avatar_uri: "avatar_fgh".into(),
-                id: 103,
-                name: None,
-            }),
-            nonce: 5,
-            mentions: Vec::new(),
-            reply_to_message_id: None,
-            edited_at: None,
-        };
-
-        let message = ChatPanel::render_markdown_with_mentions(
-            &language_registry,
-            102,
-            &message,
-            UtcOffset::UTC,
-            cx,
-        );
-
-        // Note that the "'" was replaced with ’ due to smart punctuation.
-        let (body, ranges) = marked_text_ranges(
-            "«Here is a link »«https://zed.dev»« to zeds website»",
-            false,
-        );
-        assert_eq!(message.text, body);
-        assert_eq!(3, ranges.len());
-        assert_eq!(
-            message.highlights,
-            vec![
-                (
-                    ranges[0].clone(),
-                    HighlightStyle {
-                        font_weight: Some(gpui::FontWeight::BOLD),
-                        ..Default::default()
-                    }
-                    .into()
-                ),
-                (
-                    ranges[1].clone(),
-                    HighlightStyle {
-                        font_weight: Some(gpui::FontWeight::BOLD),
-                        underline: Some(gpui::UnderlineStyle {
-                            thickness: 1.0.into(),
-                            ..Default::default()
-                        }),
-                        ..Default::default()
-                    }
-                    .into()
-                ),
-                (
-                    ranges[2].clone(),
-                    HighlightStyle {
-                        font_weight: Some(gpui::FontWeight::BOLD),
-                        ..Default::default()
-                    }
-                    .into()
-                ),
-            ]
-        );
-    }
-}
diff --git a/crates/collab_ui/src/chat_panel/message_editor.rs b/crates/collab_ui/src/chat_panel/message_editor.rs
deleted file mode 100644
index 3864ca69d88dd8231aa4b2f5b656c11f41b07282..0000000000000000000000000000000000000000
--- a/crates/collab_ui/src/chat_panel/message_editor.rs
+++ /dev/null
@@ -1,548 +0,0 @@
-use anyhow::{Context as _, Result};
-use channel::{ChannelChat, ChannelStore, MessageParams};
-use client::{UserId, UserStore};
-use collections::HashSet;
-use editor::{AnchorRangeExt, CompletionProvider, Editor, EditorElement, EditorStyle, ExcerptId};
-use fuzzy::{StringMatch, StringMatchCandidate};
-use gpui::{
-    AsyncApp, AsyncWindowContext, Context, Entity, Focusable, FontStyle, FontWeight,
-    HighlightStyle, IntoElement, Render, Task, TextStyle, WeakEntity, Window,
-};
-use language::{
-    Anchor, Buffer, BufferSnapshot, CodeLabel, LanguageRegistry, ToOffset,
-    language_settings::SoftWrap,
-};
-use project::{
-    Completion, CompletionDisplayOptions, CompletionResponse, CompletionSource, search::SearchQuery,
-};
-use settings::Settings;
-use std::{
-    ops::Range,
-    rc::Rc,
-    sync::{Arc, LazyLock},
-    time::Duration,
-};
-use theme::ThemeSettings;
-use ui::{TextSize, prelude::*};
-
-use crate::panel_settings::MessageEditorSettings;
-
-const MENTIONS_DEBOUNCE_INTERVAL: Duration = Duration::from_millis(50);
-
-static MENTIONS_SEARCH: LazyLock<SearchQuery> = LazyLock::new(|| {
-    SearchQuery::regex(
-        "@[-_\\w]+",
-        false,
-        false,
-        false,
-        false,
-        Default::default(),
-        Default::default(),
-        false,
-        None,
-    )
-    .unwrap()
-});
-
-pub struct MessageEditor {
-    pub editor: Entity<Editor>,
-    user_store: Entity<UserStore>,
-    channel_chat: Option<Entity<ChannelChat>>,
-    mentions: Vec<UserId>,
-    mentions_task: Option<Task<()>>,
-    reply_to_message_id: Option<u64>,
-    edit_message_id: Option<u64>,
-}
-
-struct MessageEditorCompletionProvider(WeakEntity<MessageEditor>);
-
-impl CompletionProvider for MessageEditorCompletionProvider {
-    fn completions(
-        &self,
-        _excerpt_id: ExcerptId,
-        buffer: &Entity<Buffer>,
-        buffer_position: language::Anchor,
-        _: editor::CompletionContext,
-        _window: &mut Window,
-        cx: &mut Context<Editor>,
-    ) -> Task<Result<Vec<CompletionResponse>>> {
-        let Some(handle) = self.0.upgrade() else {
-            return Task::ready(Ok(Vec::new()));
-        };
-        handle.update(cx, |message_editor, cx| {
-            message_editor.completions(buffer, buffer_position, cx)
-        })
-    }
-
-    fn is_completion_trigger(
-        &self,
-        _buffer: &Entity<Buffer>,
-        _position: language::Anchor,
-        text: &str,
-        _trigger_in_words: bool,
-        _menu_is_open: bool,
-        _cx: &mut Context<Editor>,
-    ) -> bool {
-        text == "@"
-    }
-}
-
-impl MessageEditor {
-    pub fn new(
-        language_registry: Arc<LanguageRegistry>,
-        user_store: Entity<UserStore>,
-        channel_chat: Option<Entity<ChannelChat>>,
-        editor: Entity<Editor>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Self {
-        let this = cx.entity().downgrade();
-        editor.update(cx, |editor, cx| {
-            editor.set_soft_wrap_mode(SoftWrap::EditorWidth, cx);
-            editor.set_offset_content(false, cx);
-            editor.set_use_autoclose(false);
-            editor.set_show_gutter(false, cx);
-            editor.set_show_wrap_guides(false, cx);
-            editor.set_show_indent_guides(false, cx);
-            editor.set_completion_provider(Some(Rc::new(MessageEditorCompletionProvider(this))));
-            editor.set_auto_replace_emoji_shortcode(
-                MessageEditorSettings::get_global(cx)
-                    .auto_replace_emoji_shortcode
-                    .unwrap_or_default(),
-            );
-        });
-
-        let buffer = editor
-            .read(cx)
-            .buffer()
-            .read(cx)
-            .as_singleton()
-            .expect("message editor must be singleton");
-
-        cx.subscribe_in(&buffer, window, Self::on_buffer_event)
-            .detach();
-        cx.observe_global::<settings::SettingsStore>(|this, cx| {
-            this.editor.update(cx, |editor, cx| {
-                editor.set_auto_replace_emoji_shortcode(
-                    MessageEditorSettings::get_global(cx)
-                        .auto_replace_emoji_shortcode
-                        .unwrap_or_default(),
-                )
-            })
-        })
-        .detach();
-
-        let markdown = language_registry.language_for_name("Markdown");
-        cx.spawn_in(window, async move |_, cx| {
-            let markdown = markdown.await.context("failed to load Markdown language")?;
-            buffer.update(cx, |buffer, cx| buffer.set_language(Some(markdown), cx))
-        })
-        .detach_and_log_err(cx);
-
-        Self {
-            editor,
-            user_store,
-            channel_chat,
-            mentions: Vec::new(),
-            mentions_task: None,
-            reply_to_message_id: None,
-            edit_message_id: None,
-        }
-    }
-
-    pub fn reply_to_message_id(&self) -> Option<u64> {
-        self.reply_to_message_id
-    }
-
-    pub fn set_reply_to_message_id(&mut self, reply_to_message_id: u64) {
-        self.reply_to_message_id = Some(reply_to_message_id);
-    }
-
-    pub fn clear_reply_to_message_id(&mut self) {
-        self.reply_to_message_id = None;
-    }
-
-    pub fn edit_message_id(&self) -> Option<u64> {
-        self.edit_message_id
-    }
-
-    pub fn set_edit_message_id(&mut self, edit_message_id: u64) {
-        self.edit_message_id = Some(edit_message_id);
-    }
-
-    pub fn clear_edit_message_id(&mut self) {
-        self.edit_message_id = None;
-    }
-
-    pub fn set_channel_chat(&mut self, chat: Entity<ChannelChat>, cx: &mut Context<Self>) {
-        let channel_id = chat.read(cx).channel_id;
-        self.channel_chat = Some(chat);
-        let channel_name = ChannelStore::global(cx)
-            .read(cx)
-            .channel_for_id(channel_id)
-            .map(|channel| channel.name.clone());
-        self.editor.update(cx, |editor, cx| {
-            if let Some(channel_name) = channel_name {
-                editor.set_placeholder_text(format!("Message #{channel_name}"), cx);
-            } else {
-                editor.set_placeholder_text("Message Channel", cx);
-            }
-        });
-    }
-
-    pub fn take_message(&mut self, window: &mut Window, cx: &mut Context<Self>) -> MessageParams {
-        self.editor.update(cx, |editor, cx| {
-            let highlights = editor.text_highlights::<Self>(cx);
-            let text = editor.text(cx);
-            let snapshot = editor.buffer().read(cx).snapshot(cx);
-            let mentions = if let Some((_, ranges)) = highlights {
-                ranges
-                    .iter()
-                    .map(|range| range.to_offset(&snapshot))
-                    .zip(self.mentions.iter().copied())
-                    .collect()
-            } else {
-                Vec::new()
-            };
-
-            editor.clear(window, cx);
-            self.mentions.clear();
-            let reply_to_message_id = std::mem::take(&mut self.reply_to_message_id);
-
-            MessageParams {
-                text,
-                mentions,
-                reply_to_message_id,
-            }
-        })
-    }
-
-    fn on_buffer_event(
-        &mut self,
-        buffer: &Entity<Buffer>,
-        event: &language::BufferEvent,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        if let language::BufferEvent::Reparsed | language::BufferEvent::Edited = event {
-            let buffer = buffer.read(cx).snapshot();
-            self.mentions_task = Some(cx.spawn_in(window, async move |this, cx| {
-                cx.background_executor()
-                    .timer(MENTIONS_DEBOUNCE_INTERVAL)
-                    .await;
-                Self::find_mentions(this, buffer, cx).await;
-            }));
-        }
-    }
-
-    fn completions(
-        &mut self,
-        buffer: &Entity<Buffer>,
-        end_anchor: Anchor,
-        cx: &mut Context<Self>,
-    ) -> Task<Result<Vec<CompletionResponse>>> {
-        if let Some((start_anchor, query, candidates)) =
-            self.collect_mention_candidates(buffer, end_anchor, cx)
-            && !candidates.is_empty()
-        {
-            return cx.spawn(async move |_, cx| {
-                let completion_response = Self::completions_for_candidates(
-                    cx,
-                    query.as_str(),
-                    &candidates,
-                    start_anchor..end_anchor,
-                    Self::completion_for_mention,
-                )
-                .await;
-                Ok(vec![completion_response])
-            });
-        }
-
-        if let Some((start_anchor, query, candidates)) =
-            self.collect_emoji_candidates(buffer, end_anchor, cx)
-            && !candidates.is_empty()
-        {
-            return cx.spawn(async move |_, cx| {
-                let completion_response = Self::completions_for_candidates(
-                    cx,
-                    query.as_str(),
-                    candidates,
-                    start_anchor..end_anchor,
-                    Self::completion_for_emoji,
-                )
-                .await;
-                Ok(vec![completion_response])
-            });
-        }
-
-        Task::ready(Ok(vec![CompletionResponse {
-            completions: Vec::new(),
-            display_options: CompletionDisplayOptions::default(),
-            is_incomplete: false,
-        }]))
-    }
-
-    async fn completions_for_candidates(
-        cx: &AsyncApp,
-        query: &str,
-        candidates: &[StringMatchCandidate],
-        range: Range<Anchor>,
-        completion_fn: impl Fn(&StringMatch) -> (String, CodeLabel),
-    ) -> CompletionResponse {
-        const LIMIT: usize = 10;
-        let matches = fuzzy::match_strings(
-            candidates,
-            query,
-            true,
-            true,
-            LIMIT,
-            &Default::default(),
-            cx.background_executor().clone(),
-        )
-        .await;
-
-        let completions = matches
-            .into_iter()
-            .map(|mat| {
-                let (new_text, label) = completion_fn(&mat);
-                Completion {
-                    replace_range: range.clone(),
-                    new_text,
-                    label,
-                    icon_path: None,
-                    confirm: None,
-                    documentation: None,
-                    insert_text_mode: None,
-                    source: CompletionSource::Custom,
-                }
-            })
-            .collect::<Vec<_>>();
-
-        CompletionResponse {
-            is_incomplete: completions.len() >= LIMIT,
-            display_options: CompletionDisplayOptions::default(),
-            completions,
-        }
-    }
-
-    fn completion_for_mention(mat: &StringMatch) -> (String, CodeLabel) {
-        let label = CodeLabel {
-            filter_range: 1..mat.string.len() + 1,
-            text: format!("@{}", mat.string),
-            runs: Vec::new(),
-        };
-        (mat.string.clone(), label)
-    }
-
-    fn completion_for_emoji(mat: &StringMatch) -> (String, CodeLabel) {
-        let emoji = emojis::get_by_shortcode(&mat.string).unwrap();
-        let label = CodeLabel {
-            filter_range: 1..mat.string.len() + 1,
-            text: format!(":{}: {}", mat.string, emoji),
-            runs: Vec::new(),
-        };
-        (emoji.to_string(), label)
-    }
-
-    fn collect_mention_candidates(
-        &mut self,
-        buffer: &Entity<Buffer>,
-        end_anchor: Anchor,
-        cx: &mut Context<Self>,
-    ) -> Option<(Anchor, String, Vec<StringMatchCandidate>)> {
-        let end_offset = end_anchor.to_offset(buffer.read(cx));
-
-        let query = buffer.read_with(cx, |buffer, _| {
-            let mut query = String::new();
-            for ch in buffer.reversed_chars_at(end_offset).take(100) {
-                if ch == '@' {
-                    return Some(query.chars().rev().collect::<String>());
-                }
-                if ch.is_whitespace() || !ch.is_ascii() {
-                    break;
-                }
-                query.push(ch);
-            }
-            None
-        })?;
-
-        let start_offset = end_offset - query.len();
-        let start_anchor = buffer.read(cx).anchor_before(start_offset);
-
-        let mut names = HashSet::default();
-        if let Some(chat) = self.channel_chat.as_ref() {
-            let chat = chat.read(cx);
-            for participant in ChannelStore::global(cx)
-                .read(cx)
-                .channel_participants(chat.channel_id)
-            {
-                names.insert(participant.github_login.clone());
-            }
-            for message in chat
-                .messages_in_range(chat.message_count().saturating_sub(100)..chat.message_count())
-            {
-                names.insert(message.sender.github_login.clone());
-            }
-        }
-
-        let candidates = names
-            .into_iter()
-            .map(|user| StringMatchCandidate::new(0, &user))
-            .collect::<Vec<_>>();
-
-        Some((start_anchor, query, candidates))
-    }
-
-    fn collect_emoji_candidates(
-        &mut self,
-        buffer: &Entity<Buffer>,
-        end_anchor: Anchor,
-        cx: &mut Context<Self>,
-    ) -> Option<(Anchor, String, &'static [StringMatchCandidate])> {
-        static EMOJI_FUZZY_MATCH_CANDIDATES: LazyLock<Vec<StringMatchCandidate>> =
-            LazyLock::new(|| {
-                emojis::iter()
-                    .flat_map(|s| s.shortcodes())
-                    .map(|emoji| StringMatchCandidate::new(0, emoji))
-                    .collect::<Vec<_>>()
-            });
-
-        let end_offset = end_anchor.to_offset(buffer.read(cx));
-
-        let query = buffer.read_with(cx, |buffer, _| {
-            let mut query = String::new();
-            for ch in buffer.reversed_chars_at(end_offset).take(100) {
-                if ch == ':' {
-                    let next_char = buffer
-                        .reversed_chars_at(end_offset - query.len() - 1)
-                        .next();
-                    // Ensure we are at the start of the message or that the previous character is a whitespace
-                    if next_char.is_none() || next_char.unwrap().is_whitespace() {
-                        return Some(query.chars().rev().collect::<String>());
-                    }
-
-                    // If the previous character is not a whitespace, we are in the middle of a word
-                    // and we only want to complete the shortcode if the word is made up of other emojis
-                    let mut containing_word = String::new();
-                    for ch in buffer
-                        .reversed_chars_at(end_offset - query.len() - 1)
-                        .take(100)
-                    {
-                        if ch.is_whitespace() {
-                            break;
-                        }
-                        containing_word.push(ch);
-                    }
-                    let containing_word = containing_word.chars().rev().collect::<String>();
-                    if util::word_consists_of_emojis(containing_word.as_str()) {
-                        return Some(query.chars().rev().collect::<String>());
-                    }
-                    break;
-                }
-                if ch.is_whitespace() || !ch.is_ascii() {
-                    break;
-                }
-                query.push(ch);
-            }
-            None
-        })?;
-
-        let start_offset = end_offset - query.len() - 1;
-        let start_anchor = buffer.read(cx).anchor_before(start_offset);
-
-        Some((start_anchor, query, &EMOJI_FUZZY_MATCH_CANDIDATES))
-    }
-
-    async fn find_mentions(
-        this: WeakEntity<MessageEditor>,
-        buffer: BufferSnapshot,
-        cx: &mut AsyncWindowContext,
-    ) {
-        let (buffer, ranges) = cx
-            .background_spawn(async move {
-                let ranges = MENTIONS_SEARCH.search(&buffer, None).await;
-                (buffer, ranges)
-            })
-            .await;
-
-        this.update(cx, |this, cx| {
-            let mut anchor_ranges = Vec::new();
-            let mut mentioned_user_ids = Vec::new();
-            let mut text = String::new();
-
-            this.editor.update(cx, |editor, cx| {
-                let multi_buffer = editor.buffer().read(cx).snapshot(cx);
-                for range in ranges {
-                    text.clear();
-                    text.extend(buffer.text_for_range(range.clone()));
-                    if let Some(username) = text.strip_prefix('@')
-                        && let Some(user) = this
-                            .user_store
-                            .read(cx)
-                            .cached_user_by_github_login(username)
-                    {
-                        let start = multi_buffer.anchor_after(range.start);
-                        let end = multi_buffer.anchor_after(range.end);
-
-                        mentioned_user_ids.push(user.id);
-                        anchor_ranges.push(start..end);
-                    }
-                }
-
-                editor.clear_highlights::<Self>(cx);
-                editor.highlight_text::<Self>(
-                    anchor_ranges,
-                    HighlightStyle {
-                        font_weight: Some(FontWeight::BOLD),
-                        ..Default::default()
-                    },
-                    cx,
-                )
-            });
-
-            this.mentions = mentioned_user_ids;
-            this.mentions_task.take();
-        })
-        .ok();
-    }
-
-    pub(crate) fn focus_handle(&self, cx: &gpui::App) -> gpui::FocusHandle {
-        self.editor.read(cx).focus_handle(cx)
-    }
-}
-
-impl Render for MessageEditor {
-    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let settings = ThemeSettings::get_global(cx);
-        let text_style = TextStyle {
-            color: if self.editor.read(cx).read_only(cx) {
-                cx.theme().colors().text_disabled
-            } else {
-                cx.theme().colors().text
-            },
-            font_family: settings.ui_font.family.clone(),
-            font_features: settings.ui_font.features.clone(),
-            font_fallbacks: settings.ui_font.fallbacks.clone(),
-            font_size: TextSize::Small.rems(cx).into(),
-            font_weight: settings.ui_font.weight,
-            font_style: FontStyle::Normal,
-            line_height: relative(1.3),
-            ..Default::default()
-        };
-
-        div()
-            .w_full()
-            .px_2()
-            .py_1()
-            .bg(cx.theme().colors().editor_background)
-            .rounded_sm()
-            .child(EditorElement::new(
-                &self.editor,
-                EditorStyle {
-                    local_player: cx.theme().players().local(),
-                    text: text_style,
-                    ..Default::default()
-                },
-            ))
-    }
-}
diff --git a/crates/collab_ui/src/collab_panel.rs b/crates/collab_ui/src/collab_panel.rs
index 90096542942e18ff9a0355d6319e5dcf590a870c..b9ef535f1dbc781405cfe74584ca03f461f66c34 100644
--- a/crates/collab_ui/src/collab_panel.rs
+++ b/crates/collab_ui/src/collab_panel.rs
@@ -2,7 +2,7 @@ mod channel_modal;
 mod contact_finder;
 
 use self::channel_modal::ChannelModal;
-use crate::{CollaborationPanelSettings, channel_view::ChannelView, chat_panel::ChatPanel};
+use crate::{CollaborationPanelSettings, channel_view::ChannelView};
 use anyhow::Context as _;
 use call::ActiveCall;
 use channel::{Channel, ChannelEvent, ChannelStore};
@@ -38,7 +38,7 @@ use util::{ResultExt, TryFutureExt, maybe};
 use workspace::{
     Deafen, LeaveCall, Mute, OpenChannelNotes, ScreenShare, ShareProject, Workspace,
     dock::{DockPosition, Panel, PanelEvent},
-    notifications::{DetachAndPromptErr, NotifyResultExt, NotifyTaskExt},
+    notifications::{DetachAndPromptErr, NotifyResultExt},
 };
 
 actions!(
@@ -261,9 +261,6 @@ enum ListEntry {
     ChannelNotes {
         channel_id: ChannelId,
     },
-    ChannelChat {
-        channel_id: ChannelId,
-    },
     ChannelEditor {
         depth: usize,
     },
@@ -495,7 +492,6 @@ impl CollabPanel {
                     && let Some(channel_id) = room.channel_id()
                 {
                     self.entries.push(ListEntry::ChannelNotes { channel_id });
-                    self.entries.push(ListEntry::ChannelChat { channel_id });
                 }
 
                 // Populate the active user.
@@ -1089,39 +1085,6 @@ impl CollabPanel {
             .tooltip(Tooltip::text("Open Channel Notes"))
     }
 
-    fn render_channel_chat(
-        &self,
-        channel_id: ChannelId,
-        is_selected: bool,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> impl IntoElement {
-        let channel_store = self.channel_store.read(cx);
-        let has_messages_notification = channel_store.has_new_messages(channel_id);
-        ListItem::new("channel-chat")
-            .toggle_state(is_selected)
-            .on_click(cx.listener(move |this, _, window, cx| {
-                this.join_channel_chat(channel_id, window, cx);
-            }))
-            .start_slot(
-                h_flex()
-                    .relative()
-                    .gap_1()
-                    .child(render_tree_branch(false, false, window, cx))
-                    .child(IconButton::new(0, IconName::Chat))
-                    .children(has_messages_notification.then(|| {
-                        div()
-                            .w_1p5()
-                            .absolute()
-                            .right(px(2.))
-                            .top(px(4.))
-                            .child(Indicator::dot().color(Color::Info))
-                    })),
-            )
-            .child(Label::new("chat"))
-            .tooltip(Tooltip::text("Open Chat"))
-    }
-
     fn has_subchannels(&self, ix: usize) -> bool {
         self.entries.get(ix).is_some_and(|entry| {
             if let ListEntry::Channel { has_children, .. } = entry {
@@ -1296,13 +1259,6 @@ impl CollabPanel {
                         this.open_channel_notes(channel_id, window, cx)
                     }),
                 )
-                .entry(
-                    "Open Chat",
-                    None,
-                    window.handler_for(&this, move |this, window, cx| {
-                        this.join_channel_chat(channel_id, window, cx)
-                    }),
-                )
                 .entry(
                     "Copy Channel Link",
                     None,
@@ -1632,9 +1588,6 @@ impl CollabPanel {
                 ListEntry::ChannelNotes { channel_id } => {
                     self.open_channel_notes(*channel_id, window, cx)
                 }
-                ListEntry::ChannelChat { channel_id } => {
-                    self.join_channel_chat(*channel_id, window, cx)
-                }
                 ListEntry::OutgoingRequest(_) => {}
                 ListEntry::ChannelEditor { .. } => {}
             }
@@ -2258,28 +2211,6 @@ impl CollabPanel {
         .detach_and_prompt_err("Failed to join channel", window, cx, |_, _, _| None)
     }
 
-    fn join_channel_chat(
-        &mut self,
-        channel_id: ChannelId,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        let Some(workspace) = self.workspace.upgrade() else {
-            return;
-        };
-        window.defer(cx, move |window, cx| {
-            workspace.update(cx, |workspace, cx| {
-                if let Some(panel) = workspace.focus_panel::<ChatPanel>(window, cx) {
-                    panel.update(cx, |panel, cx| {
-                        panel
-                            .select_channel(channel_id, None, cx)
-                            .detach_and_notify_err(window, cx);
-                    });
-                }
-            });
-        });
-    }
-
     fn copy_channel_link(&mut self, channel_id: ChannelId, cx: &mut Context<Self>) {
         let channel_store = self.channel_store.read(cx);
         let Some(channel) = channel_store.channel_for_id(channel_id) else {
@@ -2398,9 +2329,6 @@ impl CollabPanel {
             ListEntry::ChannelNotes { channel_id } => self
                 .render_channel_notes(*channel_id, is_selected, window, cx)
                 .into_any_element(),
-            ListEntry::ChannelChat { channel_id } => self
-                .render_channel_chat(*channel_id, is_selected, window, cx)
-                .into_any_element(),
         }
     }
 
@@ -2781,7 +2709,6 @@ impl CollabPanel {
         let disclosed =
             has_children.then(|| self.collapsed_channels.binary_search(&channel.id).is_err());
 
-        let has_messages_notification = channel_store.has_new_messages(channel_id);
         let has_notes_notification = channel_store.has_channel_buffer_changed(channel_id);
 
         const FACEPILE_LIMIT: usize = 3;
@@ -2909,21 +2836,6 @@ impl CollabPanel {
                         .rounded_l_sm()
                         .gap_1()
                         .px_1()
-                        .child(
-                            IconButton::new("channel_chat", IconName::Chat)
-                                .style(ButtonStyle::Filled)
-                                .shape(ui::IconButtonShape::Square)
-                                .icon_size(IconSize::Small)
-                                .icon_color(if has_messages_notification {
-                                    Color::Default
-                                } else {
-                                    Color::Muted
-                                })
-                                .on_click(cx.listener(move |this, _, window, cx| {
-                                    this.join_channel_chat(channel_id, window, cx)
-                                }))
-                                .tooltip(Tooltip::text("Open channel chat")),
-                        )
                         .child(
                             IconButton::new("channel_notes", IconName::Reader)
                                 .style(ButtonStyle::Filled)
@@ -3183,14 +3095,6 @@ impl PartialEq for ListEntry {
                     return channel_id == other_id;
                 }
             }
-            ListEntry::ChannelChat { channel_id } => {
-                if let ListEntry::ChannelChat {
-                    channel_id: other_id,
-                } = other
-                {
-                    return channel_id == other_id;
-                }
-            }
             ListEntry::ChannelInvite(channel_1) => {
                 if let ListEntry::ChannelInvite(channel_2) = other {
                     return channel_1.id == channel_2.id;
diff --git a/crates/collab_ui/src/collab_ui.rs b/crates/collab_ui/src/collab_ui.rs
index b369d324adb617907d80b773e0982c1723b1bae6..f75dd663c838c84f167b3070b50a4e1f44e9aa2d 100644
--- a/crates/collab_ui/src/collab_ui.rs
+++ b/crates/collab_ui/src/collab_ui.rs
@@ -1,5 +1,4 @@
 pub mod channel_view;
-pub mod chat_panel;
 pub mod collab_panel;
 pub mod notification_panel;
 pub mod notifications;
@@ -13,9 +12,7 @@ use gpui::{
     WindowDecorations, WindowKind, WindowOptions, point,
 };
 use panel_settings::MessageEditorSettings;
-pub use panel_settings::{
-    ChatPanelButton, ChatPanelSettings, CollaborationPanelSettings, NotificationPanelSettings,
-};
+pub use panel_settings::{CollaborationPanelSettings, NotificationPanelSettings};
 use release_channel::ReleaseChannel;
 use settings::Settings;
 use ui::px;
@@ -23,12 +20,10 @@ use workspace::AppState;
 
 pub fn init(app_state: &Arc<AppState>, cx: &mut App) {
     CollaborationPanelSettings::register(cx);
-    ChatPanelSettings::register(cx);
     NotificationPanelSettings::register(cx);
     MessageEditorSettings::register(cx);
 
     channel_view::init(cx);
-    chat_panel::init(cx);
     collab_panel::init(cx);
     notification_panel::init(cx);
     notifications::init(app_state, cx);
diff --git a/crates/collab_ui/src/notification_panel.rs b/crates/collab_ui/src/notification_panel.rs
index bf6fc3b224c54cd1512011987f73623c58d33c32..9731b89521e29ebda21ad5ce2cfca6e0531ae437 100644
--- a/crates/collab_ui/src/notification_panel.rs
+++ b/crates/collab_ui/src/notification_panel.rs
@@ -1,4 +1,4 @@
-use crate::{NotificationPanelSettings, chat_panel::ChatPanel};
+use crate::NotificationPanelSettings;
 use anyhow::Result;
 use channel::ChannelStore;
 use client::{ChannelId, Client, Notification, User, UserStore};
@@ -6,8 +6,8 @@ use collections::HashMap;
 use db::kvp::KEY_VALUE_STORE;
 use futures::StreamExt;
 use gpui::{
-    AnyElement, App, AsyncWindowContext, ClickEvent, Context, CursorStyle, DismissEvent, Element,
-    Entity, EventEmitter, FocusHandle, Focusable, InteractiveElement, IntoElement, ListAlignment,
+    AnyElement, App, AsyncWindowContext, ClickEvent, Context, DismissEvent, Element, Entity,
+    EventEmitter, FocusHandle, Focusable, InteractiveElement, IntoElement, ListAlignment,
     ListScrollEvent, ListState, ParentElement, Render, StatefulInteractiveElement, Styled, Task,
     WeakEntity, Window, actions, div, img, list, px,
 };
@@ -71,7 +71,6 @@ pub struct NotificationPresenter {
     pub text: String,
     pub icon: &'static str,
     pub needs_response: bool,
-    pub can_navigate: bool,
 }
 
 actions!(
@@ -234,7 +233,6 @@ impl NotificationPanel {
             actor,
             text,
             needs_response,
-            can_navigate,
             ..
         } = self.present_notification(entry, cx)?;
 
@@ -269,14 +267,6 @@ impl NotificationPanel {
                 .py_1()
                 .gap_2()
                 .hover(|style| style.bg(cx.theme().colors().element_hover))
-                .when(can_navigate, |el| {
-                    el.cursor(CursorStyle::PointingHand).on_click({
-                        let notification = notification.clone();
-                        cx.listener(move |this, _, window, cx| {
-                            this.did_click_notification(&notification, window, cx)
-                        })
-                    })
-                })
                 .children(actor.map(|actor| {
                     img(actor.avatar_uri.clone())
                         .flex_none()
@@ -369,7 +359,6 @@ impl NotificationPanel {
                     text: format!("{} wants to add you as a contact", requester.github_login),
                     needs_response: user_store.has_incoming_contact_request(requester.id),
                     actor: Some(requester),
-                    can_navigate: false,
                 })
             }
             Notification::ContactRequestAccepted { responder_id } => {
@@ -379,7 +368,6 @@ impl NotificationPanel {
                     text: format!("{} accepted your contact invite", responder.github_login),
                     needs_response: false,
                     actor: Some(responder),
-                    can_navigate: false,
                 })
             }
             Notification::ChannelInvitation {
@@ -396,29 +384,6 @@ impl NotificationPanel {
                     ),
                     needs_response: channel_store.has_channel_invitation(ChannelId(channel_id)),
                     actor: Some(inviter),
-                    can_navigate: false,
-                })
-            }
-            Notification::ChannelMessageMention {
-                sender_id,
-                channel_id,
-                message_id,
-            } => {
-                let sender = user_store.get_cached_user(sender_id)?;
-                let channel = channel_store.channel_for_id(ChannelId(channel_id))?;
-                let message = self
-                    .notification_store
-                    .read(cx)
-                    .channel_message_for_id(message_id)?;
-                Some(NotificationPresenter {
-                    icon: "icons/conversations.svg",
-                    text: format!(
-                        "{} mentioned you in #{}:\n{}",
-                        sender.github_login, channel.name, message.body,
-                    ),
-                    needs_response: false,
-                    actor: Some(sender),
-                    can_navigate: true,
                 })
             }
         }
@@ -433,9 +398,7 @@ impl NotificationPanel {
     ) {
         let should_mark_as_read = match notification {
             Notification::ContactRequestAccepted { .. } => true,
-            Notification::ContactRequest { .. }
-            | Notification::ChannelInvitation { .. }
-            | Notification::ChannelMessageMention { .. } => false,
+            Notification::ContactRequest { .. } | Notification::ChannelInvitation { .. } => false,
         };
 
         if should_mark_as_read {
@@ -457,55 +420,6 @@ impl NotificationPanel {
         }
     }
 
-    fn did_click_notification(
-        &mut self,
-        notification: &Notification,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        if let Notification::ChannelMessageMention {
-            message_id,
-            channel_id,
-            ..
-        } = notification.clone()
-            && let Some(workspace) = self.workspace.upgrade()
-        {
-            window.defer(cx, move |window, cx| {
-                workspace.update(cx, |workspace, cx| {
-                    if let Some(panel) = workspace.focus_panel::<ChatPanel>(window, cx) {
-                        panel.update(cx, |panel, cx| {
-                            panel
-                                .select_channel(ChannelId(channel_id), Some(message_id), cx)
-                                .detach_and_log_err(cx);
-                        });
-                    }
-                });
-            });
-        }
-    }
-
-    fn is_showing_notification(&self, notification: &Notification, cx: &mut Context<Self>) -> bool {
-        if !self.active {
-            return false;
-        }
-
-        if let Notification::ChannelMessageMention { channel_id, .. } = &notification
-            && let Some(workspace) = self.workspace.upgrade()
-        {
-            return if let Some(panel) = workspace.read(cx).panel::<ChatPanel>(cx) {
-                let panel = panel.read(cx);
-                panel.is_scrolled_to_bottom()
-                    && panel
-                        .active_chat()
-                        .is_some_and(|chat| chat.read(cx).channel_id.0 == *channel_id)
-            } else {
-                false
-            };
-        }
-
-        false
-    }
-
     fn on_notification_event(
         &mut self,
         _: &Entity<NotificationStore>,
@@ -515,9 +429,7 @@ impl NotificationPanel {
     ) {
         match event {
             NotificationEvent::NewNotification { entry } => {
-                if !self.is_showing_notification(&entry.notification, cx) {
-                    self.unseen_notifications.push(entry.clone());
-                }
+                self.unseen_notifications.push(entry.clone());
                 self.add_toast(entry, window, cx);
             }
             NotificationEvent::NotificationRemoved { entry }
@@ -541,10 +453,6 @@ impl NotificationPanel {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        if self.is_showing_notification(&entry.notification, cx) {
-            return;
-        }
-
         let Some(NotificationPresenter { actor, text, .. }) = self.present_notification(entry, cx)
         else {
             return;
@@ -568,7 +476,6 @@ impl NotificationPanel {
                 workspace.show_notification(id, cx, |cx| {
                     let workspace = cx.entity().downgrade();
                     cx.new(|cx| NotificationToast {
-                        notification_id,
                         actor,
                         text,
                         workspace,
@@ -781,7 +688,6 @@ impl Panel for NotificationPanel {
 }
 
 pub struct NotificationToast {
-    notification_id: u64,
     actor: Option<Arc<User>>,
     text: String,
     workspace: WeakEntity<Workspace>,
@@ -799,22 +705,10 @@ impl WorkspaceNotification for NotificationToast {}
 impl NotificationToast {
     fn focus_notification_panel(&self, window: &mut Window, cx: &mut Context<Self>) {
         let workspace = self.workspace.clone();
-        let notification_id = self.notification_id;
         window.defer(cx, move |window, cx| {
             workspace
                 .update(cx, |workspace, cx| {
-                    if let Some(panel) = workspace.focus_panel::<NotificationPanel>(window, cx) {
-                        panel.update(cx, |panel, cx| {
-                            let store = panel.notification_store.read(cx);
-                            if let Some(entry) = store.notification_for_id(notification_id) {
-                                panel.did_click_notification(
-                                    &entry.clone().notification,
-                                    window,
-                                    cx,
-                                );
-                            }
-                        });
-                    }
+                    workspace.focus_panel::<NotificationPanel>(window, cx)
                 })
                 .ok();
         })
diff --git a/crates/collab_ui/src/panel_settings.rs b/crates/collab_ui/src/panel_settings.rs
index 64f0a9366df7cdef1f2c05809752fb1cf912111b..98559ffd34006bf2f65427a899fd1fe5d41a4d11 100644
--- a/crates/collab_ui/src/panel_settings.rs
+++ b/crates/collab_ui/src/panel_settings.rs
@@ -1,7 +1,7 @@
 use gpui::Pixels;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 use workspace::dock::DockPosition;
 
 #[derive(Deserialize, Debug)]
@@ -11,31 +11,16 @@ pub struct CollaborationPanelSettings {
     pub default_width: Pixels,
 }
 
-#[derive(Clone, Copy, Default, Serialize, Deserialize, JsonSchema, Debug)]
-#[serde(rename_all = "snake_case")]
-pub enum ChatPanelButton {
-    Never,
-    Always,
-    #[default]
-    WhenInCall,
-}
-
-#[derive(Deserialize, Debug)]
-pub struct ChatPanelSettings {
-    pub button: ChatPanelButton,
-    pub dock: DockPosition,
-    pub default_width: Pixels,
-}
-
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi)]
-pub struct ChatPanelSettingsContent {
-    /// When to show the panel button in the status bar.
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi, SettingsKey)]
+#[settings_key(key = "collaboration_panel")]
+pub struct PanelSettingsContent {
+    /// Whether to show the panel button in the status bar.
     ///
-    /// Default: only when in a call
-    pub button: Option<ChatPanelButton>,
+    /// Default: true
+    pub button: Option<bool>,
     /// Where to dock the panel.
     ///
-    /// Default: right
+    /// Default: left
     pub dock: Option<DockPosition>,
     /// Default width of the panel in pixels.
     ///
@@ -50,23 +35,25 @@ pub struct NotificationPanelSettings {
     pub default_width: Pixels,
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi)]
-pub struct PanelSettingsContent {
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi, SettingsKey)]
+#[settings_key(key = "notification_panel")]
+pub struct NotificationPanelSettingsContent {
     /// Whether to show the panel button in the status bar.
     ///
     /// Default: true
     pub button: Option<bool>,
     /// Where to dock the panel.
     ///
-    /// Default: left
+    /// Default: right
     pub dock: Option<DockPosition>,
     /// Default width of the panel in pixels.
     ///
-    /// Default: 240
+    /// Default: 300
     pub default_width: Option<f32>,
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi, SettingsKey)]
+#[settings_key(key = "message_editor")]
 pub struct MessageEditorSettings {
     /// Whether to automatically replace emoji shortcodes with emoji characters.
     /// For example: typing `:wave:` gets replaced with `👋`.
@@ -76,8 +63,6 @@ pub struct MessageEditorSettings {
 }
 
 impl Settings for CollaborationPanelSettings {
-    const KEY: Option<&'static str> = Some("collaboration_panel");
-
     type FileContent = PanelSettingsContent;
 
     fn load(
@@ -90,25 +75,8 @@ impl Settings for CollaborationPanelSettings {
     fn import_from_vscode(_vscode: &settings::VsCodeSettings, _current: &mut Self::FileContent) {}
 }
 
-impl Settings for ChatPanelSettings {
-    const KEY: Option<&'static str> = Some("chat_panel");
-
-    type FileContent = ChatPanelSettingsContent;
-
-    fn load(
-        sources: SettingsSources<Self::FileContent>,
-        _: &mut gpui::App,
-    ) -> anyhow::Result<Self> {
-        sources.json_merge()
-    }
-
-    fn import_from_vscode(_vscode: &settings::VsCodeSettings, _current: &mut Self::FileContent) {}
-}
-
 impl Settings for NotificationPanelSettings {
-    const KEY: Option<&'static str> = Some("notification_panel");
-
-    type FileContent = PanelSettingsContent;
+    type FileContent = NotificationPanelSettingsContent;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
@@ -121,8 +89,6 @@ impl Settings for NotificationPanelSettings {
 }
 
 impl Settings for MessageEditorSettings {
-    const KEY: Option<&'static str> = Some("message_editor");
-
     type FileContent = MessageEditorSettings;
 
     fn load(
diff --git a/crates/command_palette_hooks/src/command_palette_hooks.rs b/crates/command_palette_hooks/src/command_palette_hooks.rs
index df64d53874b4907b3bf586ee7935302c2e6979ae..f1344c5ba6d46fce966ace60d483e3c0fc717f80 100644
--- a/crates/command_palette_hooks/src/command_palette_hooks.rs
+++ b/crates/command_palette_hooks/src/command_palette_hooks.rs
@@ -76,7 +76,7 @@ impl CommandPaletteFilter {
     }
 
     /// Hides all actions with the given types.
-    pub fn hide_action_types(&mut self, action_types: &[TypeId]) {
+    pub fn hide_action_types<'a>(&mut self, action_types: impl IntoIterator<Item = &'a TypeId>) {
         for action_type in action_types {
             self.hidden_action_types.insert(*action_type);
             self.shown_action_types.remove(action_type);
@@ -84,7 +84,7 @@ impl CommandPaletteFilter {
     }
 
     /// Shows all actions with the given types.
-    pub fn show_action_types<'a>(&mut self, action_types: impl Iterator<Item = &'a TypeId>) {
+    pub fn show_action_types<'a>(&mut self, action_types: impl IntoIterator<Item = &'a TypeId>) {
         for action_type in action_types {
             self.shown_action_types.insert(*action_type);
             self.hidden_action_types.remove(action_type);
diff --git a/crates/component/Cargo.toml b/crates/component/Cargo.toml
index 92249de454d7140343cc6f814f6ac1bd99685cda..74481834f1cab5047dec3cd32121eb002fabbbbd 100644
--- a/crates/component/Cargo.toml
+++ b/crates/component/Cargo.toml
@@ -20,5 +20,8 @@ strum.workspace = true
 theme.workspace = true
 workspace-hack.workspace = true
 
+[dev-dependencies]
+documented.workspace = true
+
 [features]
 default = []
diff --git a/crates/component/src/component.rs b/crates/component/src/component.rs
index 0c05ba4a97f4598e9f7982cbc294831a955f1fc6..8c7b7ea4d7347ff087c84880c31df5d355870f65 100644
--- a/crates/component/src/component.rs
+++ b/crates/component/src/component.rs
@@ -227,6 +227,8 @@ pub trait Component {
     /// Example:
     ///
     /// ```
+    /// use documented::Documented;
+    ///
     /// /// This is a doc comment.
     /// #[derive(Documented)]
     /// struct MyComponent;
diff --git a/crates/copilot/src/copilot.rs b/crates/copilot/src/copilot.rs
index d0a57735ab5a0342b245aa8db72e6b021b3943de..61b7a4e18e4e679c29e26185735352737983c4d1 100644
--- a/crates/copilot/src/copilot.rs
+++ b/crates/copilot/src/copilot.rs
@@ -1095,7 +1095,7 @@ impl Copilot {
                 _ => {
                     filter.hide_action_types(&signed_in_actions);
                     filter.hide_action_types(&auth_actions);
-                    filter.show_action_types(no_auth_actions.iter());
+                    filter.show_action_types(&no_auth_actions);
                 }
             }
         }
diff --git a/crates/dap/src/debugger_settings.rs b/crates/dap/src/debugger_settings.rs
index 929bff747e8685ec9a4b36fa9db63d12a769faa2..8d53fdea8649f1c62fa74cc6f0ddd6aec6ecff6d 100644
--- a/crates/dap/src/debugger_settings.rs
+++ b/crates/dap/src/debugger_settings.rs
@@ -2,7 +2,7 @@ use dap_types::SteppingGranularity;
 use gpui::{App, Global};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq, SettingsUi)]
 #[serde(rename_all = "snake_case")]
@@ -12,11 +12,12 @@ pub enum DebugPanelDockPosition {
     Right,
 }
 
-#[derive(Serialize, Deserialize, JsonSchema, Clone, Copy, SettingsUi)]
+#[derive(Serialize, Deserialize, JsonSchema, Clone, Copy, SettingsUi, SettingsKey)]
 #[serde(default)]
 // todo(settings_ui) @ben: I'm pretty sure not having the fields be optional here is a bug,
 // it means the defaults will override previously set values if a single key is missing
-#[settings_ui(group = "Debugger", path = "debugger")]
+#[settings_ui(group = "Debugger")]
+#[settings_key(key = "debugger")]
 pub struct DebuggerSettings {
     /// Determines the stepping granularity.
     ///
@@ -64,8 +65,6 @@ impl Default for DebuggerSettings {
 }
 
 impl Settings for DebuggerSettings {
-    const KEY: Option<&'static str> = Some("debugger");
-
     type FileContent = Self;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> anyhow::Result<Self> {
diff --git a/crates/debugger_ui/src/attach_modal.rs b/crates/debugger_ui/src/attach_modal.rs
index 662a98c82075cd6e936988959c855eadb5138092..3e3bc3ec27c3d1dbf0bacd445b883a50370d5b6f 100644
--- a/crates/debugger_ui/src/attach_modal.rs
+++ b/crates/debugger_ui/src/attach_modal.rs
@@ -1,8 +1,10 @@
 use dap::{DapRegistry, DebugRequest};
 use fuzzy::{StringMatch, StringMatchCandidate};
-use gpui::{AppContext, DismissEvent, Entity, EventEmitter, Focusable, Render};
+use gpui::{AppContext, DismissEvent, Entity, EventEmitter, Focusable, Render, Task};
 use gpui::{Subscription, WeakEntity};
 use picker::{Picker, PickerDelegate};
+use project::Project;
+use rpc::proto;
 use task::ZedDebugConfig;
 use util::debug_panic;
 
@@ -56,29 +58,28 @@ impl AttachModal {
     pub fn new(
         definition: ZedDebugConfig,
         workspace: WeakEntity<Workspace>,
+        project: Entity<Project>,
         modal: bool,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
-        let mut processes: Box<[_]> = System::new_all()
-            .processes()
-            .values()
-            .map(|process| {
-                let name = process.name().to_string_lossy().into_owned();
-                Candidate {
-                    name: name.into(),
-                    pid: process.pid().as_u32(),
-                    command: process
-                        .cmd()
-                        .iter()
-                        .map(|s| s.to_string_lossy().to_string())
-                        .collect::<Vec<_>>(),
-                }
-            })
-            .collect();
-        processes.sort_by_key(|k| k.name.clone());
-        let processes = processes.into_iter().collect();
-        Self::with_processes(workspace, definition, processes, modal, window, cx)
+        let processes_task = get_processes_for_project(&project, cx);
+
+        let modal = Self::with_processes(workspace, definition, Arc::new([]), modal, window, cx);
+
+        cx.spawn_in(window, async move |this, cx| {
+            let processes = processes_task.await;
+            this.update_in(cx, |modal, window, cx| {
+                modal.picker.update(cx, |picker, cx| {
+                    picker.delegate.candidates = processes;
+                    picker.refresh(window, cx);
+                });
+            })?;
+            anyhow::Ok(())
+        })
+        .detach_and_log_err(cx);
+
+        modal
     }
 
     pub(super) fn with_processes(
@@ -332,6 +333,57 @@ impl PickerDelegate for AttachModalDelegate {
     }
 }
 
+fn get_processes_for_project(project: &Entity<Project>, cx: &mut App) -> Task<Arc<[Candidate]>> {
+    let project = project.read(cx);
+
+    if let Some(remote_client) = project.remote_client() {
+        let proto_client = remote_client.read(cx).proto_client();
+        cx.spawn(async move |_cx| {
+            let response = proto_client
+                .request(proto::GetProcesses {
+                    project_id: proto::REMOTE_SERVER_PROJECT_ID,
+                })
+                .await
+                .unwrap_or_else(|_| proto::GetProcessesResponse {
+                    processes: Vec::new(),
+                });
+
+            let mut processes: Vec<Candidate> = response
+                .processes
+                .into_iter()
+                .map(|p| Candidate {
+                    pid: p.pid,
+                    name: p.name.into(),
+                    command: p.command,
+                })
+                .collect();
+
+            processes.sort_by_key(|k| k.name.clone());
+            Arc::from(processes.into_boxed_slice())
+        })
+    } else {
+        let mut processes: Box<[_]> = System::new_all()
+            .processes()
+            .values()
+            .map(|process| {
+                let name = process.name().to_string_lossy().into_owned();
+                Candidate {
+                    name: name.into(),
+                    pid: process.pid().as_u32(),
+                    command: process
+                        .cmd()
+                        .iter()
+                        .map(|s| s.to_string_lossy().to_string())
+                        .collect::<Vec<_>>(),
+                }
+            })
+            .collect();
+        processes.sort_by_key(|k| k.name.clone());
+        let processes = processes.into_iter().collect();
+        Task::ready(processes)
+    }
+}
+
 #[cfg(any(test, feature = "test-support"))]
 pub(crate) fn _process_names(modal: &AttachModal, cx: &mut Context<AttachModal>) -> Vec<String> {
     modal.picker.read_with(cx, |picker, _| {
diff --git a/crates/debugger_ui/src/dropdown_menus.rs b/crates/debugger_ui/src/dropdown_menus.rs
index c611d5d44f36b4eafb578a400da615bbd96b4cd2..376a4a41ce7b03cd07f578d85f641a6ddfc4ebe8 100644
--- a/crates/debugger_ui/src/dropdown_menus.rs
+++ b/crates/debugger_ui/src/dropdown_menus.rs
@@ -113,23 +113,6 @@ impl DebugPanel {
                 }
             };
             session_entries.push(root_entry);
-
-            session_entries.extend(
-                sessions_with_children
-                    .by_ref()
-                    .take_while(|(session, _)| {
-                        session
-                            .read(cx)
-                            .session(cx)
-                            .read(cx)
-                            .parent_id(cx)
-                            .is_some()
-                    })
-                    .map(|(session, _)| SessionListEntry {
-                        leaf: session.clone(),
-                        ancestors: vec![],
-                    }),
-            );
         }
 
         let weak = cx.weak_entity();
diff --git a/crates/debugger_ui/src/new_process_modal.rs b/crates/debugger_ui/src/new_process_modal.rs
index 68770bc8b15fbf95824de167dbc8d7fada2b5075..ee6289187ba990d5bbaa040631a1c32619857e53 100644
--- a/crates/debugger_ui/src/new_process_modal.rs
+++ b/crates/debugger_ui/src/new_process_modal.rs
@@ -20,7 +20,7 @@ use gpui::{
 };
 use itertools::Itertools as _;
 use picker::{Picker, PickerDelegate, highlighted_match_with_paths::HighlightedMatch};
-use project::{DebugScenarioContext, TaskContexts, TaskSourceKind, task_store::TaskStore};
+use project::{DebugScenarioContext, Project, TaskContexts, TaskSourceKind, task_store::TaskStore};
 use settings::Settings;
 use task::{DebugScenario, RevealTarget, ZedDebugConfig};
 use theme::ThemeSettings;
@@ -88,8 +88,10 @@ impl NewProcessModal {
             })?;
             workspace.update_in(cx, |workspace, window, cx| {
                 let workspace_handle = workspace.weak_handle();
+                let project = workspace.project().clone();
                 workspace.toggle_modal(window, cx, |window, cx| {
-                    let attach_mode = AttachMode::new(None, workspace_handle.clone(), window, cx);
+                    let attach_mode =
+                        AttachMode::new(None, workspace_handle.clone(), project, window, cx);
 
                     let debug_picker = cx.new(|cx| {
                         let delegate =
@@ -940,6 +942,7 @@ impl AttachMode {
     pub(super) fn new(
         debugger: Option<DebugAdapterName>,
         workspace: WeakEntity<Workspace>,
+        project: Entity<Project>,
         window: &mut Window,
         cx: &mut Context<NewProcessModal>,
     ) -> Entity<Self> {
@@ -950,7 +953,7 @@ impl AttachMode {
             stop_on_entry: Some(false),
         };
         let attach_picker = cx.new(|cx| {
-            let modal = AttachModal::new(definition.clone(), workspace, false, window, cx);
+            let modal = AttachModal::new(definition.clone(), workspace, project, false, window, cx);
             window.focus(&modal.focus_handle(cx));
 
             modal
diff --git a/crates/debugger_ui/src/session/running/stack_frame_list.rs b/crates/debugger_ui/src/session/running/stack_frame_list.rs
index f80173c365a047da39733c94964c473bef579e1c..e51b8da362a581c96d2872a213a8be32ff31b097 100644
--- a/crates/debugger_ui/src/session/running/stack_frame_list.rs
+++ b/crates/debugger_ui/src/session/running/stack_frame_list.rs
@@ -28,8 +28,8 @@ pub enum StackFrameListEvent {
 }
 
 /// Represents the filter applied to the stack frame list
-#[derive(PartialEq, Eq, Copy, Clone)]
-enum StackFrameFilter {
+#[derive(PartialEq, Eq, Copy, Clone, Debug)]
+pub(crate) enum StackFrameFilter {
     /// Show all frames
     All,
     /// Show only frames from the user's code
@@ -174,19 +174,29 @@ impl StackFrameList {
 
     #[cfg(test)]
     pub(crate) fn dap_stack_frames(&self, cx: &mut App) -> Vec<dap::StackFrame> {
-        self.stack_frames(cx)
-            .unwrap_or_default()
-            .into_iter()
-            .enumerate()
-            .filter(|(ix, _)| {
-                self.list_filter == StackFrameFilter::All
-                    || self
-                        .filter_entries_indices
-                        .binary_search_by_key(&ix, |ix| ix)
-                        .is_ok()
-            })
-            .map(|(_, stack_frame)| stack_frame.dap)
-            .collect()
+        match self.list_filter {
+            StackFrameFilter::All => self
+                .stack_frames(cx)
+                .unwrap_or_default()
+                .into_iter()
+                .map(|stack_frame| stack_frame.dap)
+                .collect(),
+            StackFrameFilter::OnlyUserFrames => self
+                .filter_entries_indices
+                .iter()
+                .map(|ix| match &self.entries[*ix] {
+                    StackFrameEntry::Label(label) => label,
+                    StackFrameEntry::Collapsed(_) => panic!("Collapsed tabs should not be visible"),
+                    StackFrameEntry::Normal(frame) => frame,
+                })
+                .cloned()
+                .collect(),
+        }
+    }
+
+    #[cfg(test)]
+    pub(crate) fn list_filter(&self) -> StackFrameFilter {
+        self.list_filter
     }
 
     pub fn opened_stack_frame_id(&self) -> Option<StackFrameId> {
@@ -246,6 +256,7 @@ impl StackFrameList {
                 self.entries.clear();
                 self.selected_ix = None;
                 self.list_state.reset(0);
+                self.filter_entries_indices.clear();
                 cx.emit(StackFrameListEvent::BuiltEntries);
                 cx.notify();
                 return;
@@ -263,7 +274,7 @@ impl StackFrameList {
             .unwrap_or_default();
 
         let mut filter_entries_indices = Vec::default();
-        for (ix, stack_frame) in stack_frames.iter().enumerate() {
+        for stack_frame in stack_frames.iter() {
             let frame_in_visible_worktree = stack_frame.dap.source.as_ref().is_some_and(|source| {
                 source.path.as_ref().is_some_and(|path| {
                     worktree_prefixes
@@ -273,10 +284,6 @@ impl StackFrameList {
                 })
             });
 
-            if frame_in_visible_worktree {
-                filter_entries_indices.push(ix);
-            }
-
             match stack_frame.dap.presentation_hint {
                 Some(dap::StackFramePresentationHint::Deemphasize)
                 | Some(dap::StackFramePresentationHint::Subtle) => {
@@ -302,6 +309,9 @@ impl StackFrameList {
                         first_stack_frame_with_path.get_or_insert(entries.len());
                     }
                     entries.push(StackFrameEntry::Normal(stack_frame.dap.clone()));
+                    if frame_in_visible_worktree {
+                        filter_entries_indices.push(entries.len() - 1);
+                    }
                 }
             }
         }
@@ -309,7 +319,6 @@ impl StackFrameList {
         let collapsed_entries = std::mem::take(&mut collapsed_entries);
         if !collapsed_entries.is_empty() {
             entries.push(StackFrameEntry::Collapsed(collapsed_entries));
-            self.filter_entries_indices.push(entries.len() - 1);
         }
         self.entries = entries;
         self.filter_entries_indices = filter_entries_indices;
@@ -612,7 +621,16 @@ impl StackFrameList {
         let entries = std::mem::take(stack_frames)
             .into_iter()
             .map(StackFrameEntry::Normal);
+        // HERE
+        let entries_len = entries.len();
         self.entries.splice(ix..ix + 1, entries);
+        let (Ok(filtered_indices_start) | Err(filtered_indices_start)) =
+            self.filter_entries_indices.binary_search(&ix);
+
+        for idx in &mut self.filter_entries_indices[filtered_indices_start..] {
+            *idx += entries_len - 1;
+        }
+
         self.selected_ix = Some(ix);
         self.list_state.reset(self.entries.len());
         cx.emit(StackFrameListEvent::BuiltEntries);
diff --git a/crates/debugger_ui/src/tests/stack_frame_list.rs b/crates/debugger_ui/src/tests/stack_frame_list.rs
index 023056224e177bb053f5188ced59c059c9c8ad32..a61a31d270c9d599f30185d7da3c825c51bb7898 100644
--- a/crates/debugger_ui/src/tests/stack_frame_list.rs
+++ b/crates/debugger_ui/src/tests/stack_frame_list.rs
@@ -1,6 +1,6 @@
 use crate::{
     debugger_panel::DebugPanel,
-    session::running::stack_frame_list::StackFrameEntry,
+    session::running::stack_frame_list::{StackFrameEntry, StackFrameFilter},
     tests::{active_debug_session_panel, init_test, init_test_workspace, start_debug_session},
 };
 use dap::{
@@ -867,6 +867,28 @@ async fn test_stack_frame_filter(executor: BackgroundExecutor, cx: &mut TestAppC
         },
         StackFrame {
             id: 4,
+            name: "node:internal/modules/run_main2".into(),
+            source: Some(dap::Source {
+                name: Some("run_main.js".into()),
+                path: Some(path!("/usr/lib/node/internal/modules/run_main2.js").into()),
+                source_reference: None,
+                presentation_hint: None,
+                origin: None,
+                sources: None,
+                adapter_data: None,
+                checksums: None,
+            }),
+            line: 50,
+            column: 1,
+            end_line: None,
+            end_column: None,
+            can_restart: None,
+            instruction_pointer_reference: None,
+            module_id: None,
+            presentation_hint: Some(dap::StackFramePresentationHint::Deemphasize),
+        },
+        StackFrame {
+            id: 5,
             name: "doSomething".into(),
             source: Some(dap::Source {
                 name: Some("test.js".into()),
@@ -957,83 +979,119 @@ async fn test_stack_frame_filter(executor: BackgroundExecutor, cx: &mut TestAppC
 
     cx.run_until_parked();
 
-    active_debug_session_panel(workspace, cx).update_in(cx, |debug_panel_item, window, cx| {
-        let stack_frame_list = debug_panel_item
-            .running_state()
-            .update(cx, |state, _| state.stack_frame_list().clone());
+    let stack_frame_list =
+        active_debug_session_panel(workspace, cx).update_in(cx, |debug_panel_item, window, cx| {
+            let stack_frame_list = debug_panel_item
+                .running_state()
+                .update(cx, |state, _| state.stack_frame_list().clone());
+
+            stack_frame_list.update(cx, |stack_frame_list, cx| {
+                stack_frame_list.build_entries(true, window, cx);
+
+                // Verify we have the expected collapsed structure
+                assert_eq!(
+                    stack_frame_list.entries(),
+                    &vec![
+                        StackFrameEntry::Normal(stack_frames_for_assertions[0].clone()),
+                        StackFrameEntry::Collapsed(vec![
+                            stack_frames_for_assertions[1].clone(),
+                            stack_frames_for_assertions[2].clone(),
+                            stack_frames_for_assertions[3].clone()
+                        ]),
+                        StackFrameEntry::Normal(stack_frames_for_assertions[4].clone()),
+                    ]
+                );
+            });
 
-        stack_frame_list.update(cx, |stack_frame_list, cx| {
-            stack_frame_list.build_entries(true, window, cx);
+            stack_frame_list
+        });
 
-            // Verify we have the expected collapsed structure
-            assert_eq!(
-                stack_frame_list.entries(),
-                &vec![
-                    StackFrameEntry::Normal(stack_frames_for_assertions[0].clone()),
-                    StackFrameEntry::Collapsed(vec![
-                        stack_frames_for_assertions[1].clone(),
-                        stack_frames_for_assertions[2].clone()
-                    ]),
-                    StackFrameEntry::Normal(stack_frames_for_assertions[3].clone()),
-                ]
-            );
+    stack_frame_list.update(cx, |stack_frame_list, cx| {
+        let all_frames = stack_frame_list.flatten_entries(true, false);
+        assert_eq!(all_frames.len(), 5, "Should see all 5 frames initially");
 
-            // Test 1: Verify filtering works
-            let all_frames = stack_frame_list.flatten_entries(true, false);
-            assert_eq!(all_frames.len(), 4, "Should see all 4 frames initially");
+        stack_frame_list
+            .toggle_frame_filter(Some(project::debugger::session::ThreadStatus::Stopped), cx);
+        assert_eq!(
+            stack_frame_list.list_filter(),
+            StackFrameFilter::OnlyUserFrames
+        );
+    });
 
-            // Toggle to user frames only
-            stack_frame_list
-                .toggle_frame_filter(Some(project::debugger::session::ThreadStatus::Stopped), cx);
+    stack_frame_list.update(cx, |stack_frame_list, cx| {
+        let user_frames = stack_frame_list.dap_stack_frames(cx);
+        assert_eq!(user_frames.len(), 2, "Should only see 2 user frames");
+        assert_eq!(user_frames[0].name, "main");
+        assert_eq!(user_frames[1].name, "doSomething");
+
+        // Toggle back to all frames
+        stack_frame_list
+            .toggle_frame_filter(Some(project::debugger::session::ThreadStatus::Stopped), cx);
+        assert_eq!(stack_frame_list.list_filter(), StackFrameFilter::All);
+    });
 
-            let user_frames = stack_frame_list.dap_stack_frames(cx);
-            assert_eq!(user_frames.len(), 2, "Should only see 2 user frames");
-            assert_eq!(user_frames[0].name, "main");
-            assert_eq!(user_frames[1].name, "doSomething");
+    stack_frame_list.update(cx, |stack_frame_list, cx| {
+        let all_frames_again = stack_frame_list.flatten_entries(true, false);
+        assert_eq!(
+            all_frames_again.len(),
+            5,
+            "Should see all 5 frames after toggling back"
+        );
 
-            // Test 2: Verify filtering toggles correctly
-            // Check we can toggle back and see all frames again
+        // Test 3: Verify collapsed entries stay expanded
+        stack_frame_list.expand_collapsed_entry(1, cx);
+        assert_eq!(
+            stack_frame_list.entries(),
+            &vec![
+                StackFrameEntry::Normal(stack_frames_for_assertions[0].clone()),
+                StackFrameEntry::Normal(stack_frames_for_assertions[1].clone()),
+                StackFrameEntry::Normal(stack_frames_for_assertions[2].clone()),
+                StackFrameEntry::Normal(stack_frames_for_assertions[3].clone()),
+                StackFrameEntry::Normal(stack_frames_for_assertions[4].clone()),
+            ]
+        );
 
-            // Toggle back to all frames
-            stack_frame_list
-                .toggle_frame_filter(Some(project::debugger::session::ThreadStatus::Stopped), cx);
+        stack_frame_list
+            .toggle_frame_filter(Some(project::debugger::session::ThreadStatus::Stopped), cx);
+        assert_eq!(
+            stack_frame_list.list_filter(),
+            StackFrameFilter::OnlyUserFrames
+        );
+    });
 
-            let all_frames_again = stack_frame_list.flatten_entries(true, false);
-            assert_eq!(
-                all_frames_again.len(),
-                4,
-                "Should see all 4 frames after toggling back"
-            );
+    stack_frame_list.update(cx, |stack_frame_list, cx| {
+        stack_frame_list
+            .toggle_frame_filter(Some(project::debugger::session::ThreadStatus::Stopped), cx);
+        assert_eq!(stack_frame_list.list_filter(), StackFrameFilter::All);
+    });
 
-            // Test 3: Verify collapsed entries stay expanded
-            stack_frame_list.expand_collapsed_entry(1, cx);
-            assert_eq!(
-                stack_frame_list.entries(),
-                &vec![
-                    StackFrameEntry::Normal(stack_frames_for_assertions[0].clone()),
-                    StackFrameEntry::Normal(stack_frames_for_assertions[1].clone()),
-                    StackFrameEntry::Normal(stack_frames_for_assertions[2].clone()),
-                    StackFrameEntry::Normal(stack_frames_for_assertions[3].clone()),
-                ]
-            );
+    stack_frame_list.update(cx, |stack_frame_list, cx| {
+        stack_frame_list
+            .toggle_frame_filter(Some(project::debugger::session::ThreadStatus::Stopped), cx);
+        assert_eq!(
+            stack_frame_list.list_filter(),
+            StackFrameFilter::OnlyUserFrames
+        );
 
-            // Toggle filter twice
-            stack_frame_list
-                .toggle_frame_filter(Some(project::debugger::session::ThreadStatus::Stopped), cx);
-            stack_frame_list
-                .toggle_frame_filter(Some(project::debugger::session::ThreadStatus::Stopped), cx);
+        assert_eq!(
+            stack_frame_list.dap_stack_frames(cx).as_slice(),
+            &[
+                stack_frames_for_assertions[0].clone(),
+                stack_frames_for_assertions[4].clone()
+            ]
+        );
 
-            // Verify entries remain expanded
-            assert_eq!(
-                stack_frame_list.entries(),
-                &vec![
-                    StackFrameEntry::Normal(stack_frames_for_assertions[0].clone()),
-                    StackFrameEntry::Normal(stack_frames_for_assertions[1].clone()),
-                    StackFrameEntry::Normal(stack_frames_for_assertions[2].clone()),
-                    StackFrameEntry::Normal(stack_frames_for_assertions[3].clone()),
-                ],
-                "Expanded entries should remain expanded after toggling filter"
-            );
-        });
+        // Verify entries remain expanded
+        assert_eq!(
+            stack_frame_list.entries(),
+            &vec![
+                StackFrameEntry::Normal(stack_frames_for_assertions[0].clone()),
+                StackFrameEntry::Normal(stack_frames_for_assertions[1].clone()),
+                StackFrameEntry::Normal(stack_frames_for_assertions[2].clone()),
+                StackFrameEntry::Normal(stack_frames_for_assertions[3].clone()),
+                StackFrameEntry::Normal(stack_frames_for_assertions[4].clone()),
+            ],
+            "Expanded entries should remain expanded after toggling filter"
+        );
     });
 }
diff --git a/crates/diagnostics/src/buffer_diagnostics.rs b/crates/diagnostics/src/buffer_diagnostics.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3a245163822fb19c43d11a93bc48c3d276e4d502
--- /dev/null
+++ b/crates/diagnostics/src/buffer_diagnostics.rs
@@ -0,0 +1,982 @@
+use crate::{
+    DIAGNOSTICS_UPDATE_DELAY, IncludeWarnings, ToggleWarnings, context_range_for_entry,
+    diagnostic_renderer::{DiagnosticBlock, DiagnosticRenderer},
+    toolbar_controls::DiagnosticsToolbarEditor,
+};
+use anyhow::Result;
+use collections::HashMap;
+use editor::{
+    Editor, EditorEvent, ExcerptRange, MultiBuffer, PathKey,
+    display_map::{BlockPlacement, BlockProperties, BlockStyle, CustomBlockId},
+    multibuffer_context_lines,
+};
+use gpui::{
+    AnyElement, App, AppContext, Context, Entity, EntityId, EventEmitter, FocusHandle, Focusable,
+    InteractiveElement, IntoElement, ParentElement, Render, SharedString, Styled, Subscription,
+    Task, WeakEntity, Window, actions, div,
+};
+use language::{Buffer, DiagnosticEntry, Point};
+use project::{
+    DiagnosticSummary, Event, Project, ProjectItem, ProjectPath,
+    project_settings::{DiagnosticSeverity, ProjectSettings},
+};
+use settings::Settings;
+use std::{
+    any::{Any, TypeId},
+    cmp::Ordering,
+    sync::Arc,
+};
+use text::{Anchor, BufferSnapshot, OffsetRangeExt};
+use ui::{Button, ButtonStyle, Icon, IconName, Label, Tooltip, h_flex, prelude::*};
+use util::paths::PathExt;
+use workspace::{
+    ItemHandle, ItemNavHistory, ToolbarItemLocation, Workspace,
+    item::{BreadcrumbText, Item, ItemEvent, TabContentParams},
+};
+
+actions!(
+    diagnostics,
+    [
+        /// Opens the project diagnostics view for the currently focused file.
+        DeployCurrentFile,
+    ]
+);
+
+/// The `BufferDiagnosticsEditor` is meant to be used when dealing specifically
+/// with diagnostics for a single buffer, as only the excerpts of the buffer
+/// where diagnostics are available are displayed.
+pub(crate) struct BufferDiagnosticsEditor {
+    pub project: Entity<Project>,
+    focus_handle: FocusHandle,
+    editor: Entity<Editor>,
+    /// The current diagnostic entries in the `BufferDiagnosticsEditor`. Used to
+    /// allow quick comparison of updated diagnostics, to confirm if anything
+    /// has changed.
+    pub(crate) diagnostics: Vec<DiagnosticEntry<Anchor>>,
+    /// The blocks used to display the diagnostics' content in the editor, next
+    /// to the excerpts where the diagnostic originated.
+    blocks: Vec<CustomBlockId>,
+    /// Multibuffer to contain all excerpts that contain diagnostics, which are
+    /// to be rendered in the editor.
+    multibuffer: Entity<MultiBuffer>,
+    /// The buffer for which the editor is displaying diagnostics and excerpts
+    /// for.
+    buffer: Option<Entity<Buffer>>,
+    /// The path for which the editor is displaying diagnostics for.
+    project_path: ProjectPath,
+    /// Summary of the number of warnings and errors for the path. Used to
+    /// display the number of warnings and errors in the tab's content.
+    summary: DiagnosticSummary,
+    /// Whether to include warnings in the list of diagnostics shown in the
+    /// editor.
+    pub(crate) include_warnings: bool,
+    /// Keeps track of whether there's a background task already running to
+    /// update the excerpts, in order to avoid firing multiple tasks for this purpose.
+    pub(crate) update_excerpts_task: Option<Task<Result<()>>>,
+    /// The project's subscription, responsible for processing events related to
+    /// diagnostics.
+    _subscription: Subscription,
+}
+
+impl BufferDiagnosticsEditor {
+    /// Creates new instance of the `BufferDiagnosticsEditor` which can then be
+    /// displayed by adding it to a pane.
+    pub fn new(
+        project_path: ProjectPath,
+        project_handle: Entity<Project>,
+        buffer: Option<Entity<Buffer>>,
+        include_warnings: bool,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        // Subscribe to project events related to diagnostics so the
+        // `BufferDiagnosticsEditor` can update its state accordingly.
+        let project_event_subscription = cx.subscribe_in(
+            &project_handle,
+            window,
+            |buffer_diagnostics_editor, _project, event, window, cx| match event {
+                Event::DiskBasedDiagnosticsStarted { .. } => {
+                    cx.notify();
+                }
+                Event::DiskBasedDiagnosticsFinished { .. } => {
+                    buffer_diagnostics_editor.update_all_excerpts(window, cx);
+                }
+                Event::DiagnosticsUpdated {
+                    paths,
+                    language_server_id,
+                } => {
+                    // When diagnostics have been updated, the
+                    // `BufferDiagnosticsEditor` should update its state only if
+                    // one of the paths matches its `project_path`, otherwise
+                    // the event should be ignored.
+                    if paths.contains(&buffer_diagnostics_editor.project_path) {
+                        buffer_diagnostics_editor.update_diagnostic_summary(cx);
+
+                        if buffer_diagnostics_editor.editor.focus_handle(cx).contains_focused(window, cx) || buffer_diagnostics_editor.focus_handle.contains_focused(window, cx) {
+                            log::debug!("diagnostics updated for server {language_server_id}. recording change");
+                        } else {
+                            log::debug!("diagnostics updated for server {language_server_id}. updating excerpts");
+                            buffer_diagnostics_editor.update_all_excerpts(window, cx);
+                        }
+                    }
+                }
+                _ => {}
+            },
+        );
+
+        let focus_handle = cx.focus_handle();
+
+        cx.on_focus_in(
+            &focus_handle,
+            window,
+            |buffer_diagnostics_editor, window, cx| buffer_diagnostics_editor.focus_in(window, cx),
+        )
+        .detach();
+
+        cx.on_focus_out(
+            &focus_handle,
+            window,
+            |buffer_diagnostics_editor, _event, window, cx| {
+                buffer_diagnostics_editor.focus_out(window, cx)
+            },
+        )
+        .detach();
+
+        let summary = project_handle
+            .read(cx)
+            .diagnostic_summary_for_path(&project_path, cx);
+
+        let multibuffer = cx.new(|cx| MultiBuffer::new(project_handle.read(cx).capability()));
+        let max_severity = Self::max_diagnostics_severity(include_warnings);
+        let editor = cx.new(|cx| {
+            let mut editor = Editor::for_multibuffer(
+                multibuffer.clone(),
+                Some(project_handle.clone()),
+                window,
+                cx,
+            );
+            editor.set_vertical_scroll_margin(5, cx);
+            editor.disable_inline_diagnostics();
+            editor.set_max_diagnostics_severity(max_severity, cx);
+            editor.set_all_diagnostics_active(cx);
+            editor
+        });
+
+        // Subscribe to events triggered by the editor in order to correctly
+        // update the buffer's excerpts.
+        cx.subscribe_in(
+            &editor,
+            window,
+            |buffer_diagnostics_editor, _editor, event: &EditorEvent, window, cx| {
+                cx.emit(event.clone());
+
+                match event {
+                    // If the user tries to focus on the editor but there's actually
+                    // no excerpts for the buffer, focus back on the
+                    // `BufferDiagnosticsEditor` instance.
+                    EditorEvent::Focused => {
+                        if buffer_diagnostics_editor.multibuffer.read(cx).is_empty() {
+                            window.focus(&buffer_diagnostics_editor.focus_handle);
+                        }
+                    }
+                    EditorEvent::Blurred => {
+                        buffer_diagnostics_editor.update_all_excerpts(window, cx)
+                    }
+                    _ => {}
+                }
+            },
+        )
+        .detach();
+
+        let diagnostics = vec![];
+        let update_excerpts_task = None;
+        let mut buffer_diagnostics_editor = Self {
+            project: project_handle,
+            focus_handle,
+            editor,
+            diagnostics,
+            blocks: Default::default(),
+            multibuffer,
+            buffer,
+            project_path,
+            summary,
+            include_warnings,
+            update_excerpts_task,
+            _subscription: project_event_subscription,
+        };
+
+        buffer_diagnostics_editor.update_all_diagnostics(window, cx);
+        buffer_diagnostics_editor
+    }
+
+    fn deploy(
+        workspace: &mut Workspace,
+        _: &DeployCurrentFile,
+        window: &mut Window,
+        cx: &mut Context<Workspace>,
+    ) {
+        // Determine the currently opened path by finding the active editor and
+        // finding the project path for the buffer.
+        // If there's no active editor with a project path, avoiding deploying
+        // the buffer diagnostics view.
+        if let Some(editor) = workspace.active_item_as::<Editor>(cx)
+            && let Some(project_path) = editor.project_path(cx)
+        {
+            // Check if there's already a `BufferDiagnosticsEditor` tab for this
+            // same path, and if so, focus on that one instead of creating a new
+            // one.
+            let existing_editor = workspace
+                .items_of_type::<BufferDiagnosticsEditor>(cx)
+                .find(|editor| editor.read(cx).project_path == project_path);
+
+            if let Some(editor) = existing_editor {
+                workspace.activate_item(&editor, true, true, window, cx);
+            } else {
+                let include_warnings = match cx.try_global::<IncludeWarnings>() {
+                    Some(include_warnings) => include_warnings.0,
+                    None => ProjectSettings::get_global(cx).diagnostics.include_warnings,
+                };
+
+                let item = cx.new(|cx| {
+                    Self::new(
+                        project_path,
+                        workspace.project().clone(),
+                        editor.read(cx).buffer().read(cx).as_singleton(),
+                        include_warnings,
+                        window,
+                        cx,
+                    )
+                });
+
+                workspace.add_item_to_active_pane(Box::new(item), None, true, window, cx);
+            }
+        }
+    }
+
+    pub fn register(
+        workspace: &mut Workspace,
+        _window: Option<&mut Window>,
+        _: &mut Context<Workspace>,
+    ) {
+        workspace.register_action(Self::deploy);
+    }
+
+    fn update_all_diagnostics(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        self.update_all_excerpts(window, cx);
+    }
+
+    fn update_diagnostic_summary(&mut self, cx: &mut Context<Self>) {
+        let project = self.project.read(cx);
+
+        self.summary = project.diagnostic_summary_for_path(&self.project_path, cx);
+    }
+
+    /// Enqueue an update to the excerpts and diagnostic blocks being shown in
+    /// the editor.
+    pub(crate) fn update_all_excerpts(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        // If there's already a task updating the excerpts, early return and let
+        // the other task finish.
+        if self.update_excerpts_task.is_some() {
+            return;
+        }
+
+        let buffer = self.buffer.clone();
+
+        self.update_excerpts_task = Some(cx.spawn_in(window, async move |editor, cx| {
+            cx.background_executor()
+                .timer(DIAGNOSTICS_UPDATE_DELAY)
+                .await;
+
+            if let Some(buffer) = buffer {
+                editor
+                    .update_in(cx, |editor, window, cx| {
+                        editor.update_excerpts(buffer, window, cx)
+                    })?
+                    .await?;
+            };
+
+            let _ = editor.update(cx, |editor, cx| {
+                editor.update_excerpts_task = None;
+                cx.notify();
+            });
+
+            Ok(())
+        }));
+    }
+
+    /// Updates the excerpts in the `BufferDiagnosticsEditor` for a single
+    /// buffer.
+    fn update_excerpts(
+        &mut self,
+        buffer: Entity<Buffer>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        let was_empty = self.multibuffer.read(cx).is_empty();
+        let multibuffer_context = multibuffer_context_lines(cx);
+        let buffer_snapshot = buffer.read(cx).snapshot();
+        let buffer_snapshot_max = buffer_snapshot.max_point();
+        let max_severity = Self::max_diagnostics_severity(self.include_warnings)
+            .into_lsp()
+            .unwrap_or(lsp::DiagnosticSeverity::WARNING);
+
+        cx.spawn_in(window, async move |buffer_diagnostics_editor, mut cx| {
+            // Fetch the diagnostics for the whole of the buffer
+            // (`Point::zero()..buffer_snapshot.max_point()`) so we can confirm
+            // if the diagnostics changed, if it didn't, early return as there's
+            // nothing to update.
+            let diagnostics = buffer_snapshot
+                .diagnostics_in_range::<_, Anchor>(Point::zero()..buffer_snapshot_max, false)
+                .collect::<Vec<_>>();
+
+            let unchanged =
+                buffer_diagnostics_editor.update(cx, |buffer_diagnostics_editor, _cx| {
+                    if buffer_diagnostics_editor
+                        .diagnostics_are_unchanged(&diagnostics, &buffer_snapshot)
+                    {
+                        return true;
+                    }
+
+                    buffer_diagnostics_editor.set_diagnostics(&diagnostics);
+                    return false;
+                })?;
+
+            if unchanged {
+                return Ok(());
+            }
+
+            // Mapping between the Group ID and a vector of DiagnosticEntry.
+            let mut grouped: HashMap<usize, Vec<_>> = HashMap::default();
+            for entry in diagnostics {
+                grouped
+                    .entry(entry.diagnostic.group_id)
+                    .or_default()
+                    .push(DiagnosticEntry {
+                        range: entry.range.to_point(&buffer_snapshot),
+                        diagnostic: entry.diagnostic,
+                    })
+            }
+
+            let mut blocks: Vec<DiagnosticBlock> = Vec::new();
+            for (_, group) in grouped {
+                // If the minimum severity of the group is higher than the
+                // maximum severity, or it doesn't even have severity, skip this
+                // group.
+                if group
+                    .iter()
+                    .map(|d| d.diagnostic.severity)
+                    .min()
+                    .is_none_or(|severity| severity > max_severity)
+                {
+                    continue;
+                }
+
+                let diagnostic_blocks = cx.update(|_window, cx| {
+                    DiagnosticRenderer::diagnostic_blocks_for_group(
+                        group,
+                        buffer_snapshot.remote_id(),
+                        Some(Arc::new(buffer_diagnostics_editor.clone())),
+                        cx,
+                    )
+                })?;
+
+                // For each of the diagnostic blocks to be displayed in the
+                // editor, figure out its index in the list of blocks.
+                //
+                // The following rules are used to determine the order:
+                // 1. Blocks with a lower start position should come first.
+                // 2. If two blocks have the same start position, the one with
+                // the higher end position should come first.
+                for diagnostic_block in diagnostic_blocks {
+                    let index = blocks.partition_point(|probe| {
+                        match probe
+                            .initial_range
+                            .start
+                            .cmp(&diagnostic_block.initial_range.start)
+                        {
+                            Ordering::Less => true,
+                            Ordering::Greater => false,
+                            Ordering::Equal => {
+                                probe.initial_range.end > diagnostic_block.initial_range.end
+                            }
+                        }
+                    });
+
+                    blocks.insert(index, diagnostic_block);
+                }
+            }
+
+            // Build the excerpt ranges for this specific buffer's diagnostics,
+            // so those excerpts can later be used to update the excerpts shown
+            // in the editor.
+            // This is done by iterating over the list of diagnostic blocks and
+            // determine what range does the diagnostic block span.
+            let mut excerpt_ranges: Vec<ExcerptRange<Point>> = Vec::new();
+
+            for diagnostic_block in blocks.iter() {
+                let excerpt_range = context_range_for_entry(
+                    diagnostic_block.initial_range.clone(),
+                    multibuffer_context,
+                    buffer_snapshot.clone(),
+                    &mut cx,
+                )
+                .await;
+
+                let index = excerpt_ranges
+                    .binary_search_by(|probe| {
+                        probe
+                            .context
+                            .start
+                            .cmp(&excerpt_range.start)
+                            .then(probe.context.end.cmp(&excerpt_range.end))
+                            .then(
+                                probe
+                                    .primary
+                                    .start
+                                    .cmp(&diagnostic_block.initial_range.start),
+                            )
+                            .then(probe.primary.end.cmp(&diagnostic_block.initial_range.end))
+                            .then(Ordering::Greater)
+                    })
+                    .unwrap_or_else(|index| index);
+
+                excerpt_ranges.insert(
+                    index,
+                    ExcerptRange {
+                        context: excerpt_range,
+                        primary: diagnostic_block.initial_range.clone(),
+                    },
+                )
+            }
+
+            // Finally, update the editor's content with the new excerpt ranges
+            // for this editor, as well as the diagnostic blocks.
+            buffer_diagnostics_editor.update_in(cx, |buffer_diagnostics_editor, window, cx| {
+                // Remove the list of `CustomBlockId` from the editor's display
+                // map, ensuring that if any diagnostics have been solved, the
+                // associated block stops being shown.
+                let block_ids = buffer_diagnostics_editor.blocks.clone();
+
+                buffer_diagnostics_editor.editor.update(cx, |editor, cx| {
+                    editor.display_map.update(cx, |display_map, cx| {
+                        display_map.remove_blocks(block_ids.into_iter().collect(), cx);
+                    })
+                });
+
+                let (anchor_ranges, _) =
+                    buffer_diagnostics_editor
+                        .multibuffer
+                        .update(cx, |multibuffer, cx| {
+                            multibuffer.set_excerpt_ranges_for_path(
+                                PathKey::for_buffer(&buffer, cx),
+                                buffer.clone(),
+                                &buffer_snapshot,
+                                excerpt_ranges,
+                                cx,
+                            )
+                        });
+
+                if was_empty {
+                    if let Some(anchor_range) = anchor_ranges.first() {
+                        let range_to_select = anchor_range.start..anchor_range.start;
+
+                        buffer_diagnostics_editor.editor.update(cx, |editor, cx| {
+                            editor.change_selections(Default::default(), window, cx, |selection| {
+                                selection.select_anchor_ranges([range_to_select])
+                            })
+                        });
+
+                        // If the `BufferDiagnosticsEditor` is currently
+                        // focused, move focus to its editor.
+                        if buffer_diagnostics_editor.focus_handle.is_focused(window) {
+                            buffer_diagnostics_editor
+                                .editor
+                                .read(cx)
+                                .focus_handle(cx)
+                                .focus(window);
+                        }
+                    }
+                }
+
+                // Cloning the blocks before moving ownership so these can later
+                // be used to set the block contents for testing purposes.
+                #[cfg(test)]
+                let cloned_blocks = blocks.clone();
+
+                // Build new diagnostic blocks to be added to the editor's
+                // display map for the new diagnostics. Update the `blocks`
+                // property before finishing, to ensure the blocks are removed
+                // on the next execution.
+                let editor_blocks =
+                    anchor_ranges
+                        .into_iter()
+                        .zip(blocks.into_iter())
+                        .map(|(anchor, block)| {
+                            let editor = buffer_diagnostics_editor.editor.downgrade();
+
+                            BlockProperties {
+                                placement: BlockPlacement::Near(anchor.start),
+                                height: Some(1),
+                                style: BlockStyle::Flex,
+                                render: Arc::new(move |block_context| {
+                                    block.render_block(editor.clone(), block_context)
+                                }),
+                                priority: 1,
+                            }
+                        });
+
+                let block_ids = buffer_diagnostics_editor.editor.update(cx, |editor, cx| {
+                    editor.display_map.update(cx, |display_map, cx| {
+                        display_map.insert_blocks(editor_blocks, cx)
+                    })
+                });
+
+                // In order to be able to verify which diagnostic blocks are
+                // rendered in the editor, the `set_block_content_for_tests`
+                // function must be used, so that the
+                // `editor::test::editor_content_with_blocks` function can then
+                // be called to fetch these blocks.
+                #[cfg(test)]
+                {
+                    for (block_id, block) in block_ids.iter().zip(cloned_blocks.iter()) {
+                        let markdown = block.markdown.clone();
+                        editor::test::set_block_content_for_tests(
+                            &buffer_diagnostics_editor.editor,
+                            *block_id,
+                            cx,
+                            move |cx| {
+                                markdown::MarkdownElement::rendered_text(
+                                    markdown.clone(),
+                                    cx,
+                                    editor::hover_popover::diagnostics_markdown_style,
+                                )
+                            },
+                        );
+                    }
+                }
+
+                buffer_diagnostics_editor.blocks = block_ids;
+                cx.notify()
+            })
+        })
+    }
+
+    fn set_diagnostics(&mut self, diagnostics: &Vec<DiagnosticEntry<Anchor>>) {
+        self.diagnostics = diagnostics.clone();
+    }
+
+    fn diagnostics_are_unchanged(
+        &self,
+        diagnostics: &Vec<DiagnosticEntry<Anchor>>,
+        snapshot: &BufferSnapshot,
+    ) -> bool {
+        if self.diagnostics.len() != diagnostics.len() {
+            return false;
+        }
+
+        self.diagnostics
+            .iter()
+            .zip(diagnostics.iter())
+            .all(|(existing, new)| {
+                existing.diagnostic.message == new.diagnostic.message
+                    && existing.diagnostic.severity == new.diagnostic.severity
+                    && existing.diagnostic.is_primary == new.diagnostic.is_primary
+                    && existing.range.to_offset(snapshot) == new.range.to_offset(snapshot)
+            })
+    }
+
+    fn focus_in(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        // If the `BufferDiagnosticsEditor` is focused and the multibuffer is
+        // not empty, focus on the editor instead, which will allow the user to
+        // start interacting and editing the buffer's contents.
+        if self.focus_handle.is_focused(window) && !self.multibuffer.read(cx).is_empty() {
+            self.editor.focus_handle(cx).focus(window)
+        }
+    }
+
+    fn focus_out(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        if !self.focus_handle.is_focused(window) && !self.editor.focus_handle(cx).is_focused(window)
+        {
+            self.update_all_excerpts(window, cx);
+        }
+    }
+
+    pub fn toggle_warnings(
+        &mut self,
+        _: &ToggleWarnings,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let include_warnings = !self.include_warnings;
+        let max_severity = Self::max_diagnostics_severity(include_warnings);
+
+        self.editor.update(cx, |editor, cx| {
+            editor.set_max_diagnostics_severity(max_severity, cx);
+        });
+
+        self.include_warnings = include_warnings;
+        self.diagnostics.clear();
+        self.update_all_diagnostics(window, cx);
+    }
+
+    fn max_diagnostics_severity(include_warnings: bool) -> DiagnosticSeverity {
+        match include_warnings {
+            true => DiagnosticSeverity::Warning,
+            false => DiagnosticSeverity::Error,
+        }
+    }
+
+    #[cfg(test)]
+    pub fn editor(&self) -> &Entity<Editor> {
+        &self.editor
+    }
+
+    #[cfg(test)]
+    pub fn summary(&self) -> &DiagnosticSummary {
+        &self.summary
+    }
+}
+
+impl Focusable for BufferDiagnosticsEditor {
+    fn focus_handle(&self, _: &App) -> FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl EventEmitter<EditorEvent> for BufferDiagnosticsEditor {}
+
+impl Item for BufferDiagnosticsEditor {
+    type Event = EditorEvent;
+
+    fn act_as_type<'a>(
+        &'a self,
+        type_id: std::any::TypeId,
+        self_handle: &'a Entity<Self>,
+        _: &'a App,
+    ) -> Option<gpui::AnyView> {
+        if type_id == TypeId::of::<Self>() {
+            Some(self_handle.to_any())
+        } else if type_id == TypeId::of::<Editor>() {
+            Some(self.editor.to_any())
+        } else {
+            None
+        }
+    }
+
+    fn added_to_workspace(
+        &mut self,
+        workspace: &mut Workspace,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.editor.update(cx, |editor, cx| {
+            editor.added_to_workspace(workspace, window, cx)
+        });
+    }
+
+    fn breadcrumb_location(&self, _: &App) -> ToolbarItemLocation {
+        ToolbarItemLocation::PrimaryLeft
+    }
+
+    fn breadcrumbs(&self, theme: &theme::Theme, cx: &App) -> Option<Vec<BreadcrumbText>> {
+        self.editor.breadcrumbs(theme, cx)
+    }
+
+    fn can_save(&self, _cx: &App) -> bool {
+        true
+    }
+
+    fn clone_on_split(
+        &self,
+        _workspace_id: Option<workspace::WorkspaceId>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Option<Entity<Self>>
+    where
+        Self: Sized,
+    {
+        Some(cx.new(|cx| {
+            BufferDiagnosticsEditor::new(
+                self.project_path.clone(),
+                self.project.clone(),
+                self.buffer.clone(),
+                self.include_warnings,
+                window,
+                cx,
+            )
+        }))
+    }
+
+    fn deactivated(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        self.editor
+            .update(cx, |editor, cx| editor.deactivated(window, cx));
+    }
+
+    fn for_each_project_item(&self, cx: &App, f: &mut dyn FnMut(EntityId, &dyn ProjectItem)) {
+        self.editor.for_each_project_item(cx, f);
+    }
+
+    fn has_conflict(&self, cx: &App) -> bool {
+        self.multibuffer.read(cx).has_conflict(cx)
+    }
+
+    fn has_deleted_file(&self, cx: &App) -> bool {
+        self.multibuffer.read(cx).has_deleted_file(cx)
+    }
+
+    fn is_dirty(&self, cx: &App) -> bool {
+        self.multibuffer.read(cx).is_dirty(cx)
+    }
+
+    fn is_singleton(&self, _cx: &App) -> bool {
+        false
+    }
+
+    fn navigate(
+        &mut self,
+        data: Box<dyn Any>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> bool {
+        self.editor
+            .update(cx, |editor, cx| editor.navigate(data, window, cx))
+    }
+
+    fn reload(
+        &mut self,
+        project: Entity<Project>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        self.editor.reload(project, window, cx)
+    }
+
+    fn save(
+        &mut self,
+        options: workspace::item::SaveOptions,
+        project: Entity<Project>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        self.editor.save(options, project, window, cx)
+    }
+
+    fn save_as(
+        &mut self,
+        _project: Entity<Project>,
+        _path: ProjectPath,
+        _window: &mut Window,
+        _cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        unreachable!()
+    }
+
+    fn set_nav_history(
+        &mut self,
+        nav_history: ItemNavHistory,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.editor.update(cx, |editor, _| {
+            editor.set_nav_history(Some(nav_history));
+        })
+    }
+
+    // Builds the content to be displayed in the tab.
+    fn tab_content(&self, params: TabContentParams, _window: &Window, _cx: &App) -> AnyElement {
+        let error_count = self.summary.error_count;
+        let warning_count = self.summary.warning_count;
+        let label = Label::new(
+            self.project_path
+                .path
+                .file_name()
+                .map(|f| f.to_sanitized_string())
+                .unwrap_or_else(|| self.project_path.path.to_sanitized_string()),
+        );
+
+        h_flex()
+            .gap_1()
+            .child(label)
+            .when(error_count == 0 && warning_count == 0, |parent| {
+                parent.child(
+                    h_flex()
+                        .gap_1()
+                        .child(Icon::new(IconName::Check).color(Color::Success)),
+                )
+            })
+            .when(error_count > 0, |parent| {
+                parent.child(
+                    h_flex()
+                        .gap_1()
+                        .child(Icon::new(IconName::XCircle).color(Color::Error))
+                        .child(Label::new(error_count.to_string()).color(params.text_color())),
+                )
+            })
+            .when(warning_count > 0, |parent| {
+                parent.child(
+                    h_flex()
+                        .gap_1()
+                        .child(Icon::new(IconName::Warning).color(Color::Warning))
+                        .child(Label::new(warning_count.to_string()).color(params.text_color())),
+                )
+            })
+            .into_any_element()
+    }
+
+    fn tab_content_text(&self, _detail: usize, _app: &App) -> SharedString {
+        "Buffer Diagnostics".into()
+    }
+
+    fn tab_tooltip_text(&self, _: &App) -> Option<SharedString> {
+        Some(
+            format!(
+                "Buffer Diagnostics - {}",
+                self.project_path.path.to_sanitized_string()
+            )
+            .into(),
+        )
+    }
+
+    fn telemetry_event_text(&self) -> Option<&'static str> {
+        Some("Buffer Diagnostics Opened")
+    }
+
+    fn to_item_events(event: &EditorEvent, f: impl FnMut(ItemEvent)) {
+        Editor::to_item_events(event, f)
+    }
+}
+
+impl Render for BufferDiagnosticsEditor {
+    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let filename = self.project_path.path.to_sanitized_string();
+        let error_count = self.summary.error_count;
+        let warning_count = match self.include_warnings {
+            true => self.summary.warning_count,
+            false => 0,
+        };
+
+        let child = if error_count + warning_count == 0 {
+            let label = match warning_count {
+                0 => "No problems in",
+                _ => "No errors in",
+            };
+
+            v_flex()
+                .key_context("EmptyPane")
+                .size_full()
+                .gap_1()
+                .justify_center()
+                .items_center()
+                .text_center()
+                .bg(cx.theme().colors().editor_background)
+                .child(
+                    div()
+                        .h_flex()
+                        .child(Label::new(label).color(Color::Muted))
+                        .child(
+                            Button::new("open-file", filename)
+                                .style(ButtonStyle::Transparent)
+                                .tooltip(Tooltip::text("Open File"))
+                                .on_click(cx.listener(|buffer_diagnostics, _, window, cx| {
+                                    if let Some(workspace) = window.root::<Workspace>().flatten() {
+                                        workspace.update(cx, |workspace, cx| {
+                                            workspace
+                                                .open_path(
+                                                    buffer_diagnostics.project_path.clone(),
+                                                    None,
+                                                    true,
+                                                    window,
+                                                    cx,
+                                                )
+                                                .detach_and_log_err(cx);
+                                        })
+                                    }
+                                })),
+                        ),
+                )
+                .when(self.summary.warning_count > 0, |div| {
+                    let label = match self.summary.warning_count {
+                        1 => "Show 1 warning".into(),
+                        warning_count => format!("Show {} warnings", warning_count),
+                    };
+
+                    div.child(
+                        Button::new("diagnostics-show-warning-label", label).on_click(cx.listener(
+                            |buffer_diagnostics_editor, _, window, cx| {
+                                buffer_diagnostics_editor.toggle_warnings(
+                                    &Default::default(),
+                                    window,
+                                    cx,
+                                );
+                                cx.notify();
+                            },
+                        )),
+                    )
+                })
+        } else {
+            div().size_full().child(self.editor.clone())
+        };
+
+        div()
+            .key_context("Diagnostics")
+            .track_focus(&self.focus_handle(cx))
+            .size_full()
+            .child(child)
+    }
+}
+
+impl DiagnosticsToolbarEditor for WeakEntity<BufferDiagnosticsEditor> {
+    fn include_warnings(&self, cx: &App) -> bool {
+        self.read_with(cx, |buffer_diagnostics_editor, _cx| {
+            buffer_diagnostics_editor.include_warnings
+        })
+        .unwrap_or(false)
+    }
+
+    fn has_stale_excerpts(&self, _cx: &App) -> bool {
+        false
+    }
+
+    fn is_updating(&self, cx: &App) -> bool {
+        self.read_with(cx, |buffer_diagnostics_editor, cx| {
+            buffer_diagnostics_editor.update_excerpts_task.is_some()
+                || buffer_diagnostics_editor
+                    .project
+                    .read(cx)
+                    .language_servers_running_disk_based_diagnostics(cx)
+                    .next()
+                    .is_some()
+        })
+        .unwrap_or(false)
+    }
+
+    fn stop_updating(&self, cx: &mut App) {
+        let _ = self.update(cx, |buffer_diagnostics_editor, cx| {
+            buffer_diagnostics_editor.update_excerpts_task = None;
+            cx.notify();
+        });
+    }
+
+    fn refresh_diagnostics(&self, window: &mut Window, cx: &mut App) {
+        let _ = self.update(cx, |buffer_diagnostics_editor, cx| {
+            buffer_diagnostics_editor.update_all_excerpts(window, cx);
+        });
+    }
+
+    fn toggle_warnings(&self, window: &mut Window, cx: &mut App) {
+        let _ = self.update(cx, |buffer_diagnostics_editor, cx| {
+            buffer_diagnostics_editor.toggle_warnings(&Default::default(), window, cx);
+        });
+    }
+
+    fn get_diagnostics_for_buffer(
+        &self,
+        _buffer_id: text::BufferId,
+        cx: &App,
+    ) -> Vec<language::DiagnosticEntry<text::Anchor>> {
+        self.read_with(cx, |buffer_diagnostics_editor, _cx| {
+            buffer_diagnostics_editor.diagnostics.clone()
+        })
+        .unwrap_or_default()
+    }
+}
diff --git a/crates/diagnostics/src/diagnostic_renderer.rs b/crates/diagnostics/src/diagnostic_renderer.rs
index e9731f84ce258bbe55dc278eb4d2ddb0d6bab9ef..e22065afa5587e25e35e5c65ffec2e18860b6788 100644
--- a/crates/diagnostics/src/diagnostic_renderer.rs
+++ b/crates/diagnostics/src/diagnostic_renderer.rs
@@ -18,7 +18,7 @@ use ui::{
 };
 use util::maybe;
 
-use crate::ProjectDiagnosticsEditor;
+use crate::toolbar_controls::DiagnosticsToolbarEditor;
 
 pub struct DiagnosticRenderer;
 
@@ -26,7 +26,7 @@ impl DiagnosticRenderer {
     pub fn diagnostic_blocks_for_group(
         diagnostic_group: Vec<DiagnosticEntry<Point>>,
         buffer_id: BufferId,
-        diagnostics_editor: Option<WeakEntity<ProjectDiagnosticsEditor>>,
+        diagnostics_editor: Option<Arc<dyn DiagnosticsToolbarEditor>>,
         cx: &mut App,
     ) -> Vec<DiagnosticBlock> {
         let Some(primary_ix) = diagnostic_group
@@ -130,6 +130,7 @@ impl editor::DiagnosticRenderer for DiagnosticRenderer {
         cx: &mut App,
     ) -> Vec<BlockProperties<Anchor>> {
         let blocks = Self::diagnostic_blocks_for_group(diagnostic_group, buffer_id, None, cx);
+
         blocks
             .into_iter()
             .map(|block| {
@@ -182,7 +183,7 @@ pub(crate) struct DiagnosticBlock {
     pub(crate) initial_range: Range<Point>,
     pub(crate) severity: DiagnosticSeverity,
     pub(crate) markdown: Entity<Markdown>,
-    pub(crate) diagnostics_editor: Option<WeakEntity<ProjectDiagnosticsEditor>>,
+    pub(crate) diagnostics_editor: Option<Arc<dyn DiagnosticsToolbarEditor>>,
 }
 
 impl DiagnosticBlock {
@@ -233,7 +234,7 @@ impl DiagnosticBlock {
 
     pub fn open_link(
         editor: &mut Editor,
-        diagnostics_editor: &Option<WeakEntity<ProjectDiagnosticsEditor>>,
+        diagnostics_editor: &Option<Arc<dyn DiagnosticsToolbarEditor>>,
         link: SharedString,
         window: &mut Window,
         cx: &mut Context<Editor>,
@@ -254,18 +255,10 @@ impl DiagnosticBlock {
 
         if let Some(diagnostics_editor) = diagnostics_editor {
             if let Some(diagnostic) = diagnostics_editor
-                .read_with(cx, |diagnostics, _| {
-                    diagnostics
-                        .diagnostics
-                        .get(&buffer_id)
-                        .cloned()
-                        .unwrap_or_default()
-                        .into_iter()
-                        .filter(|d| d.diagnostic.group_id == group_id)
-                        .nth(ix)
-                })
-                .ok()
-                .flatten()
+                .get_diagnostics_for_buffer(buffer_id, cx)
+                .into_iter()
+                .filter(|d| d.diagnostic.group_id == group_id)
+                .nth(ix)
             {
                 let multibuffer = editor.buffer().read(cx);
                 let Some(snapshot) = multibuffer
@@ -297,9 +290,9 @@ impl DiagnosticBlock {
         };
     }
 
-    fn jump_to<T: ToOffset>(
+    fn jump_to<I: ToOffset>(
         editor: &mut Editor,
-        range: Range<T>,
+        range: Range<I>,
         window: &mut Window,
         cx: &mut Context<Editor>,
     ) {
diff --git a/crates/diagnostics/src/diagnostics.rs b/crates/diagnostics/src/diagnostics.rs
index 53d03718475da1eeaf2b6b3faa22baabb1695f2d..ef4d6ec4395189971da710fd5378f65b19199a16 100644
--- a/crates/diagnostics/src/diagnostics.rs
+++ b/crates/diagnostics/src/diagnostics.rs
@@ -1,12 +1,14 @@
 pub mod items;
 mod toolbar_controls;
 
+mod buffer_diagnostics;
 mod diagnostic_renderer;
 
 #[cfg(test)]
 mod diagnostics_tests;
 
 use anyhow::Result;
+use buffer_diagnostics::BufferDiagnosticsEditor;
 use collections::{BTreeSet, HashMap};
 use diagnostic_renderer::DiagnosticBlock;
 use editor::{
@@ -36,6 +38,7 @@ use std::{
 };
 use text::{BufferId, OffsetRangeExt};
 use theme::ActiveTheme;
+use toolbar_controls::DiagnosticsToolbarEditor;
 pub use toolbar_controls::ToolbarControls;
 use ui::{Icon, IconName, Label, h_flex, prelude::*};
 use util::ResultExt;
@@ -64,6 +67,7 @@ impl Global for IncludeWarnings {}
 pub fn init(cx: &mut App) {
     editor::set_diagnostic_renderer(diagnostic_renderer::DiagnosticRenderer {}, cx);
     cx.observe_new(ProjectDiagnosticsEditor::register).detach();
+    cx.observe_new(BufferDiagnosticsEditor::register).detach();
 }
 
 pub(crate) struct ProjectDiagnosticsEditor {
@@ -85,6 +89,7 @@ pub(crate) struct ProjectDiagnosticsEditor {
 impl EventEmitter<EditorEvent> for ProjectDiagnosticsEditor {}
 
 const DIAGNOSTICS_UPDATE_DELAY: Duration = Duration::from_millis(50);
+const DIAGNOSTICS_SUMMARY_UPDATE_DELAY: Duration = Duration::from_millis(30);
 
 impl Render for ProjectDiagnosticsEditor {
     fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
@@ -94,43 +99,44 @@ impl Render for ProjectDiagnosticsEditor {
             0
         };
 
-        let child = if warning_count + self.summary.error_count == 0 {
-            let label = if self.summary.warning_count == 0 {
-                SharedString::new_static("No problems in workspace")
+        let child =
+            if warning_count + self.summary.error_count == 0 && self.editor.read(cx).is_empty(cx) {
+                let label = if self.summary.warning_count == 0 {
+                    SharedString::new_static("No problems in workspace")
+                } else {
+                    SharedString::new_static("No errors in workspace")
+                };
+                v_flex()
+                    .key_context("EmptyPane")
+                    .size_full()
+                    .gap_1()
+                    .justify_center()
+                    .items_center()
+                    .text_center()
+                    .bg(cx.theme().colors().editor_background)
+                    .child(Label::new(label).color(Color::Muted))
+                    .when(self.summary.warning_count > 0, |this| {
+                        let plural_suffix = if self.summary.warning_count > 1 {
+                            "s"
+                        } else {
+                            ""
+                        };
+                        let label = format!(
+                            "Show {} warning{}",
+                            self.summary.warning_count, plural_suffix
+                        );
+                        this.child(
+                            Button::new("diagnostics-show-warning-label", label).on_click(
+                                cx.listener(|this, _, window, cx| {
+                                    this.toggle_warnings(&Default::default(), window, cx);
+                                    cx.notify();
+                                }),
+                            ),
+                        )
+                    })
             } else {
-                SharedString::new_static("No errors in workspace")
+                div().size_full().child(self.editor.clone())
             };
-            v_flex()
-                .key_context("EmptyPane")
-                .size_full()
-                .gap_1()
-                .justify_center()
-                .items_center()
-                .text_center()
-                .bg(cx.theme().colors().editor_background)
-                .child(Label::new(label).color(Color::Muted))
-                .when(self.summary.warning_count > 0, |this| {
-                    let plural_suffix = if self.summary.warning_count > 1 {
-                        "s"
-                    } else {
-                        ""
-                    };
-                    let label = format!(
-                        "Show {} warning{}",
-                        self.summary.warning_count, plural_suffix
-                    );
-                    this.child(
-                        Button::new("diagnostics-show-warning-label", label).on_click(cx.listener(
-                            |this, _, window, cx| {
-                                this.toggle_warnings(&Default::default(), window, cx);
-                                cx.notify();
-                            },
-                        )),
-                    )
-                })
-        } else {
-            div().size_full().child(self.editor.clone())
-        };
 
         div()
             .key_context("Diagnostics")
@@ -143,7 +149,7 @@ impl Render for ProjectDiagnosticsEditor {
 }
 
 impl ProjectDiagnosticsEditor {
-    fn register(
+    pub fn register(
         workspace: &mut Workspace,
         _window: Option<&mut Window>,
         _: &mut Context<Workspace>,
@@ -159,7 +165,7 @@ impl ProjectDiagnosticsEditor {
         cx: &mut Context<Self>,
     ) -> Self {
         let project_event_subscription =
-            cx.subscribe_in(&project_handle, window, |this, project, event, window, cx| match event {
+            cx.subscribe_in(&project_handle, window, |this, _project, event, window, cx| match event {
                 project::Event::DiskBasedDiagnosticsStarted { .. } => {
                     cx.notify();
                 }
@@ -172,13 +178,12 @@ impl ProjectDiagnosticsEditor {
                     paths,
                 } => {
                     this.paths_to_update.extend(paths.clone());
-                    let project = project.clone();
                     this.diagnostic_summary_update = cx.spawn(async move |this, cx| {
                         cx.background_executor()
-                            .timer(Duration::from_millis(30))
+                            .timer(DIAGNOSTICS_SUMMARY_UPDATE_DELAY)
                             .await;
                         this.update(cx, |this, cx| {
-                            this.summary = project.read(cx).diagnostic_summary(false, cx);
+                            this.update_diagnostic_summary(cx);
                         })
                         .log_err();
                     });
@@ -233,6 +238,7 @@ impl ProjectDiagnosticsEditor {
                         }
                     }
                     EditorEvent::Blurred => this.update_stale_excerpts(window, cx),
+                    EditorEvent::Saved => this.update_stale_excerpts(window, cx),
                     _ => {}
                 }
             },
@@ -277,7 +283,7 @@ impl ProjectDiagnosticsEditor {
     }
 
     fn update_stale_excerpts(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        if self.update_excerpts_task.is_some() {
+        if self.update_excerpts_task.is_some() || self.multibuffer.read(cx).is_dirty(cx) {
             return;
         }
 
@@ -324,6 +330,7 @@ impl ProjectDiagnosticsEditor {
             let is_active = workspace
                 .active_item(cx)
                 .is_some_and(|item| item.item_id() == existing.item_id());
+
             workspace.activate_item(&existing, true, !is_active, window, cx);
         } else {
             let workspace_handle = cx.entity().downgrade();
@@ -381,22 +388,25 @@ impl ProjectDiagnosticsEditor {
     /// currently have diagnostics or are currently present in this view.
     fn update_all_excerpts(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         self.project.update(cx, |project, cx| {
-            let mut paths = project
+            let mut project_paths = project
                 .diagnostic_summaries(false, cx)
-                .map(|(path, _, _)| path)
+                .map(|(project_path, _, _)| project_path)
                 .collect::<BTreeSet<_>>();
+
             self.multibuffer.update(cx, |multibuffer, cx| {
                 for buffer in multibuffer.all_buffers() {
                     if let Some(file) = buffer.read(cx).file() {
-                        paths.insert(ProjectPath {
+                        project_paths.insert(ProjectPath {
                             path: file.path().clone(),
                             worktree_id: file.worktree_id(cx),
                         });
                     }
                 }
             });
-            self.paths_to_update = paths;
+
+            self.paths_to_update = project_paths;
         });
+
         self.update_stale_excerpts(window, cx);
     }
 
@@ -426,6 +436,7 @@ impl ProjectDiagnosticsEditor {
         let was_empty = self.multibuffer.read(cx).is_empty();
         let buffer_snapshot = buffer.read(cx).snapshot();
         let buffer_id = buffer_snapshot.remote_id();
+
         let max_severity = if self.include_warnings {
             lsp::DiagnosticSeverity::WARNING
         } else {
@@ -439,6 +450,7 @@ impl ProjectDiagnosticsEditor {
                     false,
                 )
                 .collect::<Vec<_>>();
+
             let unchanged = this.update(cx, |this, _| {
                 if this.diagnostics.get(&buffer_id).is_some_and(|existing| {
                     this.diagnostics_are_unchanged(existing, &diagnostics, &buffer_snapshot)
@@ -473,7 +485,7 @@ impl ProjectDiagnosticsEditor {
                     crate::diagnostic_renderer::DiagnosticRenderer::diagnostic_blocks_for_group(
                         group,
                         buffer_snapshot.remote_id(),
-                        Some(this.clone()),
+                        Some(Arc::new(this.clone())),
                         cx,
                     )
                 })?;
@@ -503,6 +515,7 @@ impl ProjectDiagnosticsEditor {
                     cx,
                 )
                 .await;
+
                 let i = excerpt_ranges
                     .binary_search_by(|probe| {
                         probe
@@ -572,6 +585,7 @@ impl ProjectDiagnosticsEditor {
                                 priority: 1,
                             }
                         });
+
                 let block_ids = this.editor.update(cx, |editor, cx| {
                     editor.display_map.update(cx, |display_map, cx| {
                         display_map.insert_blocks(editor_blocks, cx)
@@ -602,6 +616,10 @@ impl ProjectDiagnosticsEditor {
             })
         })
     }
+
+    fn update_diagnostic_summary(&mut self, cx: &mut Context<Self>) {
+        self.summary = self.project.read(cx).diagnostic_summary(false, cx);
+    }
 }
 
 impl Focusable for ProjectDiagnosticsEditor {
@@ -810,6 +828,68 @@ impl Item for ProjectDiagnosticsEditor {
     }
 }
 
+impl DiagnosticsToolbarEditor for WeakEntity<ProjectDiagnosticsEditor> {
+    fn include_warnings(&self, cx: &App) -> bool {
+        self.read_with(cx, |project_diagnostics_editor, _cx| {
+            project_diagnostics_editor.include_warnings
+        })
+        .unwrap_or(false)
+    }
+
+    fn has_stale_excerpts(&self, cx: &App) -> bool {
+        self.read_with(cx, |project_diagnostics_editor, _cx| {
+            !project_diagnostics_editor.paths_to_update.is_empty()
+        })
+        .unwrap_or(false)
+    }
+
+    fn is_updating(&self, cx: &App) -> bool {
+        self.read_with(cx, |project_diagnostics_editor, cx| {
+            project_diagnostics_editor.update_excerpts_task.is_some()
+                || project_diagnostics_editor
+                    .project
+                    .read(cx)
+                    .language_servers_running_disk_based_diagnostics(cx)
+                    .next()
+                    .is_some()
+        })
+        .unwrap_or(false)
+    }
+
+    fn stop_updating(&self, cx: &mut App) {
+        let _ = self.update(cx, |project_diagnostics_editor, cx| {
+            project_diagnostics_editor.update_excerpts_task = None;
+            cx.notify();
+        });
+    }
+
+    fn refresh_diagnostics(&self, window: &mut Window, cx: &mut App) {
+        let _ = self.update(cx, |project_diagnostics_editor, cx| {
+            project_diagnostics_editor.update_all_excerpts(window, cx);
+        });
+    }
+
+    fn toggle_warnings(&self, window: &mut Window, cx: &mut App) {
+        let _ = self.update(cx, |project_diagnostics_editor, cx| {
+            project_diagnostics_editor.toggle_warnings(&Default::default(), window, cx);
+        });
+    }
+
+    fn get_diagnostics_for_buffer(
+        &self,
+        buffer_id: text::BufferId,
+        cx: &App,
+    ) -> Vec<language::DiagnosticEntry<text::Anchor>> {
+        self.read_with(cx, |project_diagnostics_editor, _cx| {
+            project_diagnostics_editor
+                .diagnostics
+                .get(&buffer_id)
+                .cloned()
+                .unwrap_or_default()
+        })
+        .unwrap_or_default()
+    }
+}
 const DIAGNOSTIC_EXPANSION_ROW_LIMIT: u32 = 32;
 
 async fn context_range_for_entry(
diff --git a/crates/diagnostics/src/diagnostics_tests.rs b/crates/diagnostics/src/diagnostics_tests.rs
index fdca32520d1e08d562ac6f533968c146b5ec0673..a50e20f579e67010819de0fdb7273d4c9912b8b8 100644
--- a/crates/diagnostics/src/diagnostics_tests.rs
+++ b/crates/diagnostics/src/diagnostics_tests.rs
@@ -682,7 +682,7 @@ async fn test_random_diagnostics_blocks(cx: &mut TestAppContext, mut rng: StdRng
         Default::default();
 
     for _ in 0..operations {
-        match rng.gen_range(0..100) {
+        match rng.random_range(0..100) {
             // language server completes its diagnostic check
             0..=20 if !updated_language_servers.is_empty() => {
                 let server_id = *updated_language_servers.iter().choose(&mut rng).unwrap();
@@ -691,7 +691,7 @@ async fn test_random_diagnostics_blocks(cx: &mut TestAppContext, mut rng: StdRng
                     lsp_store.disk_based_diagnostics_finished(server_id, cx)
                 });
 
-                if rng.gen_bool(0.5) {
+                if rng.random_bool(0.5) {
                     cx.run_until_parked();
                 }
             }
@@ -701,7 +701,7 @@ async fn test_random_diagnostics_blocks(cx: &mut TestAppContext, mut rng: StdRng
                 let (path, server_id, diagnostics) =
                     match current_diagnostics.iter_mut().choose(&mut rng) {
                         // update existing set of diagnostics
-                        Some(((path, server_id), diagnostics)) if rng.gen_bool(0.5) => {
+                        Some(((path, server_id), diagnostics)) if rng.random_bool(0.5) => {
                             (path.clone(), *server_id, diagnostics)
                         }
 
@@ -709,13 +709,13 @@ async fn test_random_diagnostics_blocks(cx: &mut TestAppContext, mut rng: StdRng
                         _ => {
                             let path: PathBuf =
                                 format!(path!("/test/{}.rs"), post_inc(&mut next_filename)).into();
-                            let len = rng.gen_range(128..256);
+                            let len = rng.random_range(128..256);
                             let content =
                                 RandomCharIter::new(&mut rng).take(len).collect::<String>();
                             fs.insert_file(&path, content.into_bytes()).await;
 
                             let server_id = match language_server_ids.iter().choose(&mut rng) {
-                                Some(server_id) if rng.gen_bool(0.5) => *server_id,
+                                Some(server_id) if rng.random_bool(0.5) => *server_id,
                                 _ => {
                                     let id = LanguageServerId(language_server_ids.len());
                                     language_server_ids.push(id);
@@ -846,7 +846,7 @@ async fn test_random_diagnostics_with_inlays(cx: &mut TestAppContext, mut rng: S
     let mut next_inlay_id = 0;
 
     for _ in 0..operations {
-        match rng.gen_range(0..100) {
+        match rng.random_range(0..100) {
             // language server completes its diagnostic check
             0..=20 if !updated_language_servers.is_empty() => {
                 let server_id = *updated_language_servers.iter().choose(&mut rng).unwrap();
@@ -855,7 +855,7 @@ async fn test_random_diagnostics_with_inlays(cx: &mut TestAppContext, mut rng: S
                     lsp_store.disk_based_diagnostics_finished(server_id, cx)
                 });
 
-                if rng.gen_bool(0.5) {
+                if rng.random_bool(0.5) {
                     cx.run_until_parked();
                 }
             }
@@ -864,7 +864,7 @@ async fn test_random_diagnostics_with_inlays(cx: &mut TestAppContext, mut rng: S
                 diagnostics.editor.update(cx, |editor, cx| {
                     let snapshot = editor.snapshot(window, cx);
                     if !snapshot.buffer_snapshot.is_empty() {
-                        let position = rng.gen_range(0..snapshot.buffer_snapshot.len());
+                        let position = rng.random_range(0..snapshot.buffer_snapshot.len());
                         let position = snapshot.buffer_snapshot.clip_offset(position, Bias::Left);
                         log::info!(
                             "adding inlay at {position}/{}: {:?}",
@@ -890,7 +890,7 @@ async fn test_random_diagnostics_with_inlays(cx: &mut TestAppContext, mut rng: S
                 let (path, server_id, diagnostics) =
                     match current_diagnostics.iter_mut().choose(&mut rng) {
                         // update existing set of diagnostics
-                        Some(((path, server_id), diagnostics)) if rng.gen_bool(0.5) => {
+                        Some(((path, server_id), diagnostics)) if rng.random_bool(0.5) => {
                             (path.clone(), *server_id, diagnostics)
                         }
 
@@ -898,13 +898,13 @@ async fn test_random_diagnostics_with_inlays(cx: &mut TestAppContext, mut rng: S
                         _ => {
                             let path: PathBuf =
                                 format!(path!("/test/{}.rs"), post_inc(&mut next_filename)).into();
-                            let len = rng.gen_range(128..256);
+                            let len = rng.random_range(128..256);
                             let content =
                                 RandomCharIter::new(&mut rng).take(len).collect::<String>();
                             fs.insert_file(&path, content.into_bytes()).await;
 
                             let server_id = match language_server_ids.iter().choose(&mut rng) {
-                                Some(server_id) if rng.gen_bool(0.5) => *server_id,
+                                Some(server_id) if rng.random_bool(0.5) => *server_id,
                                 _ => {
                                     let id = LanguageServerId(language_server_ids.len());
                                     language_server_ids.push(id);
@@ -1567,6 +1567,440 @@ async fn go_to_diagnostic_with_severity(cx: &mut TestAppContext) {
     cx.assert_editor_state(indoc! {"error ˇwarning info hint"});
 }
 
+#[gpui::test]
+async fn test_buffer_diagnostics(cx: &mut TestAppContext) {
+    init_test(cx);
+
+    // We'll be creating two different files, both with diagnostics, so we can
+    // later verify that, since the `BufferDiagnosticsEditor` only shows
+    // diagnostics for the provided path, the diagnostics for the other file
+    // will not be shown, contrary to what happens with
+    // `ProjectDiagnosticsEditor`.
+    let fs = FakeFs::new(cx.executor());
+    fs.insert_tree(
+        path!("/test"),
+        json!({
+            "main.rs": "
+                fn main() {
+                    let x = vec![];
+                    let y = vec![];
+                    a(x);
+                    b(y);
+                    c(y);
+                    d(x);
+                }
+            "
+            .unindent(),
+            "other.rs": "
+                fn other() {
+                    let unused = 42;
+                    undefined_function();
+                }
+            "
+            .unindent(),
+        }),
+    )
+    .await;
+
+    let project = Project::test(fs.clone(), [path!("/test").as_ref()], cx).await;
+    let window = cx.add_window(|window, cx| Workspace::test_new(project.clone(), window, cx));
+    let cx = &mut VisualTestContext::from_window(*window, cx);
+    let project_path = project::ProjectPath {
+        worktree_id: project.read_with(cx, |project, cx| {
+            project.worktrees(cx).next().unwrap().read(cx).id()
+        }),
+        path: Arc::from(Path::new("main.rs")),
+    };
+    let buffer = project
+        .update(cx, |project, cx| {
+            project.open_buffer(project_path.clone(), cx)
+        })
+        .await
+        .ok();
+
+    // Create the diagnostics for `main.rs`.
+    let language_server_id = LanguageServerId(0);
+    let uri = lsp::Uri::from_file_path(path!("/test/main.rs")).unwrap();
+    let lsp_store = project.read_with(cx, |project, _| project.lsp_store());
+
+    lsp_store.update(cx, |lsp_store, cx| {
+        lsp_store.update_diagnostics(language_server_id, lsp::PublishDiagnosticsParams {
+            uri: uri.clone(),
+            diagnostics: vec![
+                lsp::Diagnostic{
+                    range: lsp::Range::new(lsp::Position::new(5, 6), lsp::Position::new(5, 7)),
+                    severity: Some(lsp::DiagnosticSeverity::WARNING),
+                    message: "use of moved value\nvalue used here after move".to_string(),
+                    related_information: Some(vec![
+                        lsp::DiagnosticRelatedInformation {
+                            location: lsp::Location::new(uri.clone(), lsp::Range::new(lsp::Position::new(2, 8), lsp::Position::new(2, 9))),
+                            message: "move occurs because `y` has type `Vec<char>`, which does not implement the `Copy` trait".to_string()
+                        },
+                        lsp::DiagnosticRelatedInformation {
+                            location: lsp::Location::new(uri.clone(), lsp::Range::new(lsp::Position::new(4, 6), lsp::Position::new(4, 7))),
+                            message: "value moved here".to_string()
+                        },
+                    ]),
+                    ..Default::default()
+                },
+                lsp::Diagnostic{
+                    range: lsp::Range::new(lsp::Position::new(6, 6), lsp::Position::new(6, 7)),
+                    severity: Some(lsp::DiagnosticSeverity::ERROR),
+                    message: "use of moved value\nvalue used here after move".to_string(),
+                    related_information: Some(vec![
+                        lsp::DiagnosticRelatedInformation {
+                            location: lsp::Location::new(uri.clone(), lsp::Range::new(lsp::Position::new(1, 8), lsp::Position::new(1, 9))),
+                            message: "move occurs because `x` has type `Vec<char>`, which does not implement the `Copy` trait".to_string()
+                        },
+                        lsp::DiagnosticRelatedInformation {
+                            location: lsp::Location::new(uri.clone(), lsp::Range::new(lsp::Position::new(3, 6), lsp::Position::new(3, 7))),
+                            message: "value moved here".to_string()
+                        },
+                    ]),
+                    ..Default::default()
+                }
+            ],
+            version: None
+        }, None, DiagnosticSourceKind::Pushed, &[], cx).unwrap();
+
+        // Create diagnostics for other.rs to ensure that the file and
+        // diagnostics are not included in `BufferDiagnosticsEditor` when it is
+        // deployed for main.rs.
+        lsp_store.update_diagnostics(language_server_id, lsp::PublishDiagnosticsParams {
+            uri: lsp::Uri::from_file_path(path!("/test/other.rs")).unwrap(),
+            diagnostics: vec![
+                lsp::Diagnostic{
+                    range: lsp::Range::new(lsp::Position::new(1, 8), lsp::Position::new(1, 14)),
+                    severity: Some(lsp::DiagnosticSeverity::WARNING),
+                    message: "unused variable: `unused`".to_string(),
+                    ..Default::default()
+                },
+                lsp::Diagnostic{
+                    range: lsp::Range::new(lsp::Position::new(2, 4), lsp::Position::new(2, 22)),
+                    severity: Some(lsp::DiagnosticSeverity::ERROR),
+                    message: "cannot find function `undefined_function` in this scope".to_string(),
+                    ..Default::default()
+                }
+            ],
+            version: None
+        }, None, DiagnosticSourceKind::Pushed, &[], cx).unwrap();
+    });
+
+    let buffer_diagnostics = window.build_entity(cx, |window, cx| {
+        BufferDiagnosticsEditor::new(
+            project_path.clone(),
+            project.clone(),
+            buffer,
+            true,
+            window,
+            cx,
+        )
+    });
+    let editor = buffer_diagnostics.update(cx, |buffer_diagnostics, _| {
+        buffer_diagnostics.editor().clone()
+    });
+
+    // Since the excerpt updates is handled by a background task, we need to
+    // wait a little bit to ensure that the buffer diagnostic's editor content
+    // is rendered.
+    cx.executor()
+        .advance_clock(DIAGNOSTICS_UPDATE_DELAY + Duration::from_millis(10));
+
+    pretty_assertions::assert_eq!(
+        editor_content_with_blocks(&editor, cx),
+        indoc::indoc! {
+            "§ main.rs
+             § -----
+             fn main() {
+                 let x = vec![];
+             § move occurs because `x` has type `Vec<char>`, which does not implement
+             § the `Copy` trait (back)
+                 let y = vec![];
+             § move occurs because `y` has type `Vec<char>`, which does not implement
+             § the `Copy` trait
+                 a(x); § value moved here
+                 b(y); § value moved here
+                 c(y);
+             § use of moved value
+             § value used here after move
+                 d(x);
+             § use of moved value
+             § value used here after move
+             § hint: move occurs because `x` has type `Vec<char>`, which does not
+             § implement the `Copy` trait
+             }"
+        }
+    );
+}
+
+#[gpui::test]
+async fn test_buffer_diagnostics_without_warnings(cx: &mut TestAppContext) {
+    init_test(cx);
+
+    let fs = FakeFs::new(cx.executor());
+    fs.insert_tree(
+        path!("/test"),
+        json!({
+            "main.rs": "
+                fn main() {
+                    let x = vec![];
+                    let y = vec![];
+                    a(x);
+                    b(y);
+                    c(y);
+                    d(x);
+                }
+            "
+            .unindent(),
+        }),
+    )
+    .await;
+
+    let project = Project::test(fs.clone(), [path!("/test").as_ref()], cx).await;
+    let window = cx.add_window(|window, cx| Workspace::test_new(project.clone(), window, cx));
+    let cx = &mut VisualTestContext::from_window(*window, cx);
+    let project_path = project::ProjectPath {
+        worktree_id: project.read_with(cx, |project, cx| {
+            project.worktrees(cx).next().unwrap().read(cx).id()
+        }),
+        path: Arc::from(Path::new("main.rs")),
+    };
+    let buffer = project
+        .update(cx, |project, cx| {
+            project.open_buffer(project_path.clone(), cx)
+        })
+        .await
+        .ok();
+
+    let language_server_id = LanguageServerId(0);
+    let uri = lsp::Uri::from_file_path(path!("/test/main.rs")).unwrap();
+    let lsp_store = project.read_with(cx, |project, _| project.lsp_store());
+
+    lsp_store.update(cx, |lsp_store, cx| {
+        lsp_store.update_diagnostics(language_server_id, lsp::PublishDiagnosticsParams {
+            uri: uri.clone(),
+            diagnostics: vec![
+                lsp::Diagnostic{
+                    range: lsp::Range::new(lsp::Position::new(5, 6), lsp::Position::new(5, 7)),
+                    severity: Some(lsp::DiagnosticSeverity::WARNING),
+                    message: "use of moved value\nvalue used here after move".to_string(),
+                    related_information: Some(vec![
+                        lsp::DiagnosticRelatedInformation {
+                            location: lsp::Location::new(uri.clone(), lsp::Range::new(lsp::Position::new(2, 8), lsp::Position::new(2, 9))),
+                            message: "move occurs because `y` has type `Vec<char>`, which does not implement the `Copy` trait".to_string()
+                        },
+                        lsp::DiagnosticRelatedInformation {
+                            location: lsp::Location::new(uri.clone(), lsp::Range::new(lsp::Position::new(4, 6), lsp::Position::new(4, 7))),
+                            message: "value moved here".to_string()
+                        },
+                    ]),
+                    ..Default::default()
+                },
+                lsp::Diagnostic{
+                    range: lsp::Range::new(lsp::Position::new(6, 6), lsp::Position::new(6, 7)),
+                    severity: Some(lsp::DiagnosticSeverity::ERROR),
+                    message: "use of moved value\nvalue used here after move".to_string(),
+                    related_information: Some(vec![
+                        lsp::DiagnosticRelatedInformation {
+                            location: lsp::Location::new(uri.clone(), lsp::Range::new(lsp::Position::new(1, 8), lsp::Position::new(1, 9))),
+                            message: "move occurs because `x` has type `Vec<char>`, which does not implement the `Copy` trait".to_string()
+                        },
+                        lsp::DiagnosticRelatedInformation {
+                            location: lsp::Location::new(uri.clone(), lsp::Range::new(lsp::Position::new(3, 6), lsp::Position::new(3, 7))),
+                            message: "value moved here".to_string()
+                        },
+                    ]),
+                    ..Default::default()
+                }
+            ],
+            version: None
+        }, None, DiagnosticSourceKind::Pushed, &[], cx).unwrap();
+    });
+
+    let include_warnings = false;
+    let buffer_diagnostics = window.build_entity(cx, |window, cx| {
+        BufferDiagnosticsEditor::new(
+            project_path.clone(),
+            project.clone(),
+            buffer,
+            include_warnings,
+            window,
+            cx,
+        )
+    });
+
+    let editor = buffer_diagnostics.update(cx, |buffer_diagnostics, _cx| {
+        buffer_diagnostics.editor().clone()
+    });
+
+    // Since the excerpt updates is handled by a background task, we need to
+    // wait a little bit to ensure that the buffer diagnostic's editor content
+    // is rendered.
+    cx.executor()
+        .advance_clock(DIAGNOSTICS_UPDATE_DELAY + Duration::from_millis(10));
+
+    pretty_assertions::assert_eq!(
+        editor_content_with_blocks(&editor, cx),
+        indoc::indoc! {
+            "§ main.rs
+             § -----
+             fn main() {
+                 let x = vec![];
+             § move occurs because `x` has type `Vec<char>`, which does not implement
+             § the `Copy` trait (back)
+                 let y = vec![];
+                 a(x); § value moved here
+                 b(y);
+                 c(y);
+                 d(x);
+             § use of moved value
+             § value used here after move
+             § hint: move occurs because `x` has type `Vec<char>`, which does not
+             § implement the `Copy` trait
+             }"
+        }
+    );
+}
+
+#[gpui::test]
+async fn test_buffer_diagnostics_multiple_servers(cx: &mut TestAppContext) {
+    init_test(cx);
+
+    let fs = FakeFs::new(cx.executor());
+    fs.insert_tree(
+        path!("/test"),
+        json!({
+            "main.rs": "
+                fn main() {
+                    let x = vec![];
+                    let y = vec![];
+                    a(x);
+                    b(y);
+                    c(y);
+                    d(x);
+                }
+            "
+            .unindent(),
+        }),
+    )
+    .await;
+
+    let project = Project::test(fs.clone(), [path!("/test").as_ref()], cx).await;
+    let window = cx.add_window(|window, cx| Workspace::test_new(project.clone(), window, cx));
+    let cx = &mut VisualTestContext::from_window(*window, cx);
+    let project_path = project::ProjectPath {
+        worktree_id: project.read_with(cx, |project, cx| {
+            project.worktrees(cx).next().unwrap().read(cx).id()
+        }),
+        path: Arc::from(Path::new("main.rs")),
+    };
+    let buffer = project
+        .update(cx, |project, cx| {
+            project.open_buffer(project_path.clone(), cx)
+        })
+        .await
+        .ok();
+
+    // Create the diagnostics for `main.rs`.
+    // Two warnings are being created, one for each language server, in order to
+    // assert that both warnings are rendered in the editor.
+    let language_server_id_a = LanguageServerId(0);
+    let language_server_id_b = LanguageServerId(1);
+    let uri = lsp::Uri::from_file_path(path!("/test/main.rs")).unwrap();
+    let lsp_store = project.read_with(cx, |project, _| project.lsp_store());
+
+    lsp_store.update(cx, |lsp_store, cx| {
+        lsp_store
+            .update_diagnostics(
+                language_server_id_a,
+                lsp::PublishDiagnosticsParams {
+                    uri: uri.clone(),
+                    diagnostics: vec![lsp::Diagnostic {
+                        range: lsp::Range::new(lsp::Position::new(5, 6), lsp::Position::new(5, 7)),
+                        severity: Some(lsp::DiagnosticSeverity::WARNING),
+                        message: "use of moved value\nvalue used here after move".to_string(),
+                        related_information: None,
+                        ..Default::default()
+                    }],
+                    version: None,
+                },
+                None,
+                DiagnosticSourceKind::Pushed,
+                &[],
+                cx,
+            )
+            .unwrap();
+
+        lsp_store
+            .update_diagnostics(
+                language_server_id_b,
+                lsp::PublishDiagnosticsParams {
+                    uri: uri.clone(),
+                    diagnostics: vec![lsp::Diagnostic {
+                        range: lsp::Range::new(lsp::Position::new(6, 6), lsp::Position::new(6, 7)),
+                        severity: Some(lsp::DiagnosticSeverity::WARNING),
+                        message: "use of moved value\nvalue used here after move".to_string(),
+                        related_information: None,
+                        ..Default::default()
+                    }],
+                    version: None,
+                },
+                None,
+                DiagnosticSourceKind::Pushed,
+                &[],
+                cx,
+            )
+            .unwrap();
+    });
+
+    let buffer_diagnostics = window.build_entity(cx, |window, cx| {
+        BufferDiagnosticsEditor::new(
+            project_path.clone(),
+            project.clone(),
+            buffer,
+            true,
+            window,
+            cx,
+        )
+    });
+    let editor = buffer_diagnostics.update(cx, |buffer_diagnostics, _| {
+        buffer_diagnostics.editor().clone()
+    });
+
+    // Since the excerpt updates is handled by a background task, we need to
+    // wait a little bit to ensure that the buffer diagnostic's editor content
+    // is rendered.
+    cx.executor()
+        .advance_clock(DIAGNOSTICS_UPDATE_DELAY + Duration::from_millis(10));
+
+    pretty_assertions::assert_eq!(
+        editor_content_with_blocks(&editor, cx),
+        indoc::indoc! {
+            "§ main.rs
+             § -----
+                 a(x);
+                 b(y);
+                 c(y);
+             § use of moved value
+             § value used here after move
+                 d(x);
+             § use of moved value
+             § value used here after move
+             }"
+        }
+    );
+
+    buffer_diagnostics.update(cx, |buffer_diagnostics, _cx| {
+        assert_eq!(
+            *buffer_diagnostics.summary(),
+            DiagnosticSummary {
+                warning_count: 2,
+                error_count: 0
+            }
+        );
+    })
+}
+
 fn init_test(cx: &mut TestAppContext) {
     cx.update(|cx| {
         zlog::init_test();
@@ -1589,10 +2023,10 @@ fn randomly_update_diagnostics_for_path(
     next_id: &mut usize,
     rng: &mut impl Rng,
 ) {
-    let mutation_count = rng.gen_range(1..=3);
+    let mutation_count = rng.random_range(1..=3);
     for _ in 0..mutation_count {
-        if rng.gen_bool(0.3) && !diagnostics.is_empty() {
-            let idx = rng.gen_range(0..diagnostics.len());
+        if rng.random_bool(0.3) && !diagnostics.is_empty() {
+            let idx = rng.random_range(0..diagnostics.len());
             log::info!("  removing diagnostic at index {idx}");
             diagnostics.remove(idx);
         } else {
@@ -1601,7 +2035,7 @@ fn randomly_update_diagnostics_for_path(
 
             let new_diagnostic = random_lsp_diagnostic(rng, fs, path, unique_id);
 
-            let ix = rng.gen_range(0..=diagnostics.len());
+            let ix = rng.random_range(0..=diagnostics.len());
             log::info!(
                 "  inserting {} at index {ix}. {},{}..{},{}",
                 new_diagnostic.message,
@@ -1638,8 +2072,8 @@ fn random_lsp_diagnostic(
     let file_content = fs.read_file_sync(path).unwrap();
     let file_text = Rope::from(String::from_utf8_lossy(&file_content).as_ref());
 
-    let start = rng.gen_range(0..file_text.len().saturating_add(ERROR_MARGIN));
-    let end = rng.gen_range(start..file_text.len().saturating_add(ERROR_MARGIN));
+    let start = rng.random_range(0..file_text.len().saturating_add(ERROR_MARGIN));
+    let end = rng.random_range(start..file_text.len().saturating_add(ERROR_MARGIN));
 
     let start_point = file_text.offset_to_point_utf16(start);
     let end_point = file_text.offset_to_point_utf16(end);
@@ -1649,7 +2083,7 @@ fn random_lsp_diagnostic(
         lsp::Position::new(end_point.row, end_point.column),
     );
 
-    let severity = if rng.gen_bool(0.5) {
+    let severity = if rng.random_bool(0.5) {
         Some(lsp::DiagnosticSeverity::ERROR)
     } else {
         Some(lsp::DiagnosticSeverity::WARNING)
@@ -1657,13 +2091,14 @@ fn random_lsp_diagnostic(
 
     let message = format!("diagnostic {unique_id}");
 
-    let related_information = if rng.gen_bool(0.3) {
-        let info_count = rng.gen_range(1..=3);
+    let related_information = if rng.random_bool(0.3) {
+        let info_count = rng.random_range(1..=3);
         let mut related_info = Vec::with_capacity(info_count);
 
         for i in 0..info_count {
-            let info_start = rng.gen_range(0..file_text.len().saturating_add(ERROR_MARGIN));
-            let info_end = rng.gen_range(info_start..file_text.len().saturating_add(ERROR_MARGIN));
+            let info_start = rng.random_range(0..file_text.len().saturating_add(ERROR_MARGIN));
+            let info_end =
+                rng.random_range(info_start..file_text.len().saturating_add(ERROR_MARGIN));
 
             let info_start_point = file_text.offset_to_point_utf16(info_start);
             let info_end_point = file_text.offset_to_point_utf16(info_end);
diff --git a/crates/diagnostics/src/items.rs b/crates/diagnostics/src/items.rs
index 7ac6d101f315674cec4fd07f4ad2df0830284124..11ee4ece96d0c4646714d808037e7a2789bcdf85 100644
--- a/crates/diagnostics/src/items.rs
+++ b/crates/diagnostics/src/items.rs
@@ -32,49 +32,38 @@ impl Render for DiagnosticIndicator {
         }
 
         let diagnostic_indicator = match (self.summary.error_count, self.summary.warning_count) {
-            (0, 0) => h_flex().map(|this| {
-                this.child(
-                    Icon::new(IconName::Check)
-                        .size(IconSize::Small)
-                        .color(Color::Default),
-                )
-            }),
-            (0, warning_count) => h_flex()
-                .gap_1()
-                .child(
-                    Icon::new(IconName::Warning)
-                        .size(IconSize::Small)
-                        .color(Color::Warning),
-                )
-                .child(Label::new(warning_count.to_string()).size(LabelSize::Small)),
-            (error_count, 0) => h_flex()
-                .gap_1()
-                .child(
-                    Icon::new(IconName::XCircle)
-                        .size(IconSize::Small)
-                        .color(Color::Error),
-                )
-                .child(Label::new(error_count.to_string()).size(LabelSize::Small)),
+            (0, 0) => h_flex().child(
+                Icon::new(IconName::Check)
+                    .size(IconSize::Small)
+                    .color(Color::Default),
+            ),
             (error_count, warning_count) => h_flex()
                 .gap_1()
-                .child(
-                    Icon::new(IconName::XCircle)
-                        .size(IconSize::Small)
-                        .color(Color::Error),
-                )
-                .child(Label::new(error_count.to_string()).size(LabelSize::Small))
-                .child(
-                    Icon::new(IconName::Warning)
-                        .size(IconSize::Small)
-                        .color(Color::Warning),
-                )
-                .child(Label::new(warning_count.to_string()).size(LabelSize::Small)),
+                .when(error_count > 0, |this| {
+                    this.child(
+                        Icon::new(IconName::XCircle)
+                            .size(IconSize::Small)
+                            .color(Color::Error),
+                    )
+                    .child(Label::new(error_count.to_string()).size(LabelSize::Small))
+                })
+                .when(warning_count > 0, |this| {
+                    this.child(
+                        Icon::new(IconName::Warning)
+                            .size(IconSize::Small)
+                            .color(Color::Warning),
+                    )
+                    .child(Label::new(warning_count.to_string()).size(LabelSize::Small))
+                }),
         };
 
         let status = if let Some(diagnostic) = &self.current_diagnostic {
-            let message = diagnostic.message.split('\n').next().unwrap().to_string();
+            let message = diagnostic
+                .message
+                .split_once('\n')
+                .map_or(&*diagnostic.message, |(first, _)| first);
             Some(
-                Button::new("diagnostic_message", message)
+                Button::new("diagnostic_message", SharedString::new(message))
                     .label_size(LabelSize::Small)
                     .tooltip(|window, cx| {
                         Tooltip::for_action(
diff --git a/crates/diagnostics/src/toolbar_controls.rs b/crates/diagnostics/src/toolbar_controls.rs
index 404db391648f4af0092c52572ee2e6d3a57a34ef..ac7bfb0f692d820f6671b0cbb03849bddab58903 100644
--- a/crates/diagnostics/src/toolbar_controls.rs
+++ b/crates/diagnostics/src/toolbar_controls.rs
@@ -1,33 +1,56 @@
-use crate::{ProjectDiagnosticsEditor, ToggleDiagnosticsRefresh};
-use gpui::{Context, Entity, EventEmitter, ParentElement, Render, WeakEntity, Window};
+use crate::{BufferDiagnosticsEditor, ProjectDiagnosticsEditor, ToggleDiagnosticsRefresh};
+use gpui::{Context, EventEmitter, ParentElement, Render, Window};
+use language::DiagnosticEntry;
+use text::{Anchor, BufferId};
 use ui::prelude::*;
 use ui::{IconButton, IconButtonShape, IconName, Tooltip};
 use workspace::{ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView, item::ItemHandle};
 
 pub struct ToolbarControls {
-    editor: Option<WeakEntity<ProjectDiagnosticsEditor>>,
+    editor: Option<Box<dyn DiagnosticsToolbarEditor>>,
+}
+
+pub(crate) trait DiagnosticsToolbarEditor: Send + Sync {
+    /// Informs the toolbar whether warnings are included in the diagnostics.
+    fn include_warnings(&self, cx: &App) -> bool;
+    /// Toggles whether warning diagnostics should be displayed by the
+    /// diagnostics editor.
+    fn toggle_warnings(&self, window: &mut Window, cx: &mut App);
+    /// Indicates whether any of the excerpts displayed by the diagnostics
+    /// editor are stale.
+    fn has_stale_excerpts(&self, cx: &App) -> bool;
+    /// Indicates whether the diagnostics editor is currently updating the
+    /// diagnostics.
+    fn is_updating(&self, cx: &App) -> bool;
+    /// Requests that the diagnostics editor stop updating the diagnostics.
+    fn stop_updating(&self, cx: &mut App);
+    /// Requests that the diagnostics editor updates the displayed diagnostics
+    /// with the latest information.
+    fn refresh_diagnostics(&self, window: &mut Window, cx: &mut App);
+    /// Returns a list of diagnostics for the provided buffer id.
+    fn get_diagnostics_for_buffer(
+        &self,
+        buffer_id: BufferId,
+        cx: &App,
+    ) -> Vec<DiagnosticEntry<Anchor>>;
 }
 
 impl Render for ToolbarControls {
     fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let mut include_warnings = false;
         let mut has_stale_excerpts = false;
+        let mut include_warnings = false;
         let mut is_updating = false;
 
-        if let Some(editor) = self.diagnostics() {
-            let diagnostics = editor.read(cx);
-            include_warnings = diagnostics.include_warnings;
-            has_stale_excerpts = !diagnostics.paths_to_update.is_empty();
-            is_updating = diagnostics.update_excerpts_task.is_some()
-                || diagnostics
-                    .project
-                    .read(cx)
-                    .language_servers_running_disk_based_diagnostics(cx)
-                    .next()
-                    .is_some();
+        match &self.editor {
+            Some(editor) => {
+                include_warnings = editor.include_warnings(cx);
+                has_stale_excerpts = editor.has_stale_excerpts(cx);
+                is_updating = editor.is_updating(cx);
+            }
+            None => {}
         }
 
-        let tooltip = if include_warnings {
+        let warning_tooltip = if include_warnings {
             "Exclude Warnings"
         } else {
             "Include Warnings"
@@ -52,11 +75,12 @@ impl Render for ToolbarControls {
                                 &ToggleDiagnosticsRefresh,
                             ))
                             .on_click(cx.listener(move |toolbar_controls, _, _, cx| {
-                                if let Some(diagnostics) = toolbar_controls.diagnostics() {
-                                    diagnostics.update(cx, |diagnostics, cx| {
-                                        diagnostics.update_excerpts_task = None;
+                                match toolbar_controls.editor() {
+                                    Some(editor) => {
+                                        editor.stop_updating(cx);
                                         cx.notify();
-                                    });
+                                    }
+                                    None => {}
                                 }
                             })),
                     )
@@ -71,12 +95,11 @@ impl Render for ToolbarControls {
                                 &ToggleDiagnosticsRefresh,
                             ))
                             .on_click(cx.listener({
-                                move |toolbar_controls, _, window, cx| {
-                                    if let Some(diagnostics) = toolbar_controls.diagnostics() {
-                                        diagnostics.update(cx, move |diagnostics, cx| {
-                                            diagnostics.update_all_excerpts(window, cx);
-                                        });
-                                    }
+                                move |toolbar_controls, _, window, cx| match toolbar_controls
+                                    .editor()
+                                {
+                                    Some(editor) => editor.refresh_diagnostics(window, cx),
+                                    None => {}
                                 }
                             })),
                     )
@@ -86,13 +109,10 @@ impl Render for ToolbarControls {
                 IconButton::new("toggle-warnings", IconName::Warning)
                     .icon_color(warning_color)
                     .shape(IconButtonShape::Square)
-                    .tooltip(Tooltip::text(tooltip))
-                    .on_click(cx.listener(|this, _, window, cx| {
-                        if let Some(editor) = this.diagnostics() {
-                            editor.update(cx, |editor, cx| {
-                                editor.toggle_warnings(&Default::default(), window, cx);
-                            });
-                        }
+                    .tooltip(Tooltip::text(warning_tooltip))
+                    .on_click(cx.listener(|this, _, window, cx| match &this.editor {
+                        Some(editor) => editor.toggle_warnings(window, cx),
+                        None => {}
                     })),
             )
     }
@@ -109,7 +129,10 @@ impl ToolbarItemView for ToolbarControls {
     ) -> ToolbarItemLocation {
         if let Some(pane_item) = active_pane_item.as_ref() {
             if let Some(editor) = pane_item.downcast::<ProjectDiagnosticsEditor>() {
-                self.editor = Some(editor.downgrade());
+                self.editor = Some(Box::new(editor.downgrade()));
+                ToolbarItemLocation::PrimaryRight
+            } else if let Some(editor) = pane_item.downcast::<BufferDiagnosticsEditor>() {
+                self.editor = Some(Box::new(editor.downgrade()));
                 ToolbarItemLocation::PrimaryRight
             } else {
                 ToolbarItemLocation::Hidden
@@ -131,7 +154,7 @@ impl ToolbarControls {
         ToolbarControls { editor: None }
     }
 
-    fn diagnostics(&self) -> Option<Entity<ProjectDiagnosticsEditor>> {
-        self.editor.as_ref()?.upgrade()
+    fn editor(&self) -> Option<&dyn DiagnosticsToolbarEditor> {
+        self.editor.as_deref()
     }
 }
diff --git a/crates/editor/src/actions.rs b/crates/editor/src/actions.rs
index 5b92f138c7bd494dd3d0fd30f3b8b3479995e53f..df467c4d5daf12c34fe546ad49fb60210ba56078 100644
--- a/crates/editor/src/actions.rs
+++ b/crates/editor/src/actions.rs
@@ -640,6 +640,10 @@ actions!(
         SelectEnclosingSymbol,
         /// Selects the next larger syntax node.
         SelectLargerSyntaxNode,
+        /// Selects the next syntax node sibling.
+        SelectNextSyntaxNode,
+        /// Selects the previous syntax node sibling.
+        SelectPreviousSyntaxNode,
         /// Extends selection left.
         SelectLeft,
         /// Selects the current line.
diff --git a/crates/editor/src/code_context_menus.rs b/crates/editor/src/code_context_menus.rs
index 6d57048985955730bef2c7840d645c87b56915fc..eef4e8643928631d4fb20f044d6f27bbded80a09 100644
--- a/crates/editor/src/code_context_menus.rs
+++ b/crates/editor/src/code_context_menus.rs
@@ -251,7 +251,7 @@ enum MarkdownCacheKey {
 pub enum CompletionsMenuSource {
     Normal,
     SnippetChoices,
-    Words,
+    Words { ignore_threshold: bool },
 }
 
 // TODO: There should really be a wrapper around fuzzy match tasks that does this.
@@ -1502,6 +1502,7 @@ impl CodeActionsMenu {
                                     this.child(
                                         h_flex()
                                             .overflow_hidden()
+                                            .text_sm()
                                             .child(
                                                 // TASK: It would be good to make lsp_action.title a SharedString to avoid allocating here.
                                                 action.lsp_action.title().replace("\n", ""),
diff --git a/crates/editor/src/display_map.rs b/crates/editor/src/display_map.rs
index c16e4a6ddbb971b44d71421d6ad868e6423eb035..3a07ee45aff60a7ffc28e76ce5f7d4f79641d4b2 100644
--- a/crates/editor/src/display_map.rs
+++ b/crates/editor/src/display_map.rs
@@ -1552,15 +1552,15 @@ pub mod tests {
             .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
             .unwrap_or(10);
 
-        let mut tab_size = rng.gen_range(1..=4);
-        let buffer_start_excerpt_header_height = rng.gen_range(1..=5);
-        let excerpt_header_height = rng.gen_range(1..=5);
+        let mut tab_size = rng.random_range(1..=4);
+        let buffer_start_excerpt_header_height = rng.random_range(1..=5);
+        let excerpt_header_height = rng.random_range(1..=5);
         let font_size = px(14.0);
         let max_wrap_width = 300.0;
-        let mut wrap_width = if rng.gen_bool(0.1) {
+        let mut wrap_width = if rng.random_bool(0.1) {
             None
         } else {
-            Some(px(rng.gen_range(0.0..=max_wrap_width)))
+            Some(px(rng.random_range(0.0..=max_wrap_width)))
         };
 
         log::info!("tab size: {}", tab_size);
@@ -1571,8 +1571,8 @@ pub mod tests {
         });
 
         let buffer = cx.update(|cx| {
-            if rng.r#gen() {
-                let len = rng.gen_range(0..10);
+            if rng.random() {
+                let len = rng.random_range(0..10);
                 let text = util::RandomCharIter::new(&mut rng)
                     .take(len)
                     .collect::<String>();
@@ -1609,12 +1609,12 @@ pub mod tests {
         log::info!("display text: {:?}", snapshot.text());
 
         for _i in 0..operations {
-            match rng.gen_range(0..100) {
+            match rng.random_range(0..100) {
                 0..=19 => {
-                    wrap_width = if rng.gen_bool(0.2) {
+                    wrap_width = if rng.random_bool(0.2) {
                         None
                     } else {
-                        Some(px(rng.gen_range(0.0..=max_wrap_width)))
+                        Some(px(rng.random_range(0.0..=max_wrap_width)))
                     };
                     log::info!("setting wrap width to {:?}", wrap_width);
                     map.update(cx, |map, cx| map.set_wrap_width(wrap_width, cx));
@@ -1634,28 +1634,27 @@ pub mod tests {
                 }
                 30..=44 => {
                     map.update(cx, |map, cx| {
-                        if rng.r#gen() || blocks.is_empty() {
+                        if rng.random() || blocks.is_empty() {
                             let buffer = map.snapshot(cx).buffer_snapshot;
-                            let block_properties = (0..rng.gen_range(1..=1))
+                            let block_properties = (0..rng.random_range(1..=1))
                                 .map(|_| {
-                                    let position =
-                                        buffer.anchor_after(buffer.clip_offset(
-                                            rng.gen_range(0..=buffer.len()),
-                                            Bias::Left,
-                                        ));
+                                    let position = buffer.anchor_after(buffer.clip_offset(
+                                        rng.random_range(0..=buffer.len()),
+                                        Bias::Left,
+                                    ));
 
-                                    let placement = if rng.r#gen() {
+                                    let placement = if rng.random() {
                                         BlockPlacement::Above(position)
                                     } else {
                                         BlockPlacement::Below(position)
                                     };
-                                    let height = rng.gen_range(1..5);
+                                    let height = rng.random_range(1..5);
                                     log::info!(
                                         "inserting block {:?} with height {}",
                                         placement.as_ref().map(|p| p.to_point(&buffer)),
                                         height
                                     );
-                                    let priority = rng.gen_range(1..100);
+                                    let priority = rng.random_range(1..100);
                                     BlockProperties {
                                         placement,
                                         style: BlockStyle::Fixed,
@@ -1668,9 +1667,9 @@ pub mod tests {
                             blocks.extend(map.insert_blocks(block_properties, cx));
                         } else {
                             blocks.shuffle(&mut rng);
-                            let remove_count = rng.gen_range(1..=4.min(blocks.len()));
+                            let remove_count = rng.random_range(1..=4.min(blocks.len()));
                             let block_ids_to_remove = (0..remove_count)
-                                .map(|_| blocks.remove(rng.gen_range(0..blocks.len())))
+                                .map(|_| blocks.remove(rng.random_range(0..blocks.len())))
                                 .collect();
                             log::info!("removing block ids {:?}", block_ids_to_remove);
                             map.remove_blocks(block_ids_to_remove, cx);
@@ -1679,16 +1678,16 @@ pub mod tests {
                 }
                 45..=79 => {
                     let mut ranges = Vec::new();
-                    for _ in 0..rng.gen_range(1..=3) {
+                    for _ in 0..rng.random_range(1..=3) {
                         buffer.read_with(cx, |buffer, cx| {
                             let buffer = buffer.read(cx);
-                            let end = buffer.clip_offset(rng.gen_range(0..=buffer.len()), Right);
-                            let start = buffer.clip_offset(rng.gen_range(0..=end), Left);
+                            let end = buffer.clip_offset(rng.random_range(0..=buffer.len()), Right);
+                            let start = buffer.clip_offset(rng.random_range(0..=end), Left);
                             ranges.push(start..end);
                         });
                     }
 
-                    if rng.r#gen() && fold_count > 0 {
+                    if rng.random() && fold_count > 0 {
                         log::info!("unfolding ranges: {:?}", ranges);
                         map.update(cx, |map, cx| {
                             map.unfold_intersecting(ranges, true, cx);
@@ -1727,8 +1726,8 @@ pub mod tests {
             // Line boundaries
             let buffer = &snapshot.buffer_snapshot;
             for _ in 0..5 {
-                let row = rng.gen_range(0..=buffer.max_point().row);
-                let column = rng.gen_range(0..=buffer.line_len(MultiBufferRow(row)));
+                let row = rng.random_range(0..=buffer.max_point().row);
+                let column = rng.random_range(0..=buffer.line_len(MultiBufferRow(row)));
                 let point = buffer.clip_point(Point::new(row, column), Left);
 
                 let (prev_buffer_bound, prev_display_bound) = snapshot.prev_line_boundary(point);
@@ -1776,8 +1775,8 @@ pub mod tests {
             let min_point = snapshot.clip_point(DisplayPoint::new(DisplayRow(0), 0), Left);
             let max_point = snapshot.clip_point(snapshot.max_point(), Right);
             for _ in 0..5 {
-                let row = rng.gen_range(0..=snapshot.max_point().row().0);
-                let column = rng.gen_range(0..=snapshot.line_len(DisplayRow(row)));
+                let row = rng.random_range(0..=snapshot.max_point().row().0);
+                let column = rng.random_range(0..=snapshot.line_len(DisplayRow(row)));
                 let point = snapshot.clip_point(DisplayPoint::new(DisplayRow(row), column), Left);
 
                 log::info!("Moving from point {:?}", point);
diff --git a/crates/editor/src/display_map/block_map.rs b/crates/editor/src/display_map/block_map.rs
index b073fe7be75c82754de6ca7773b68073b213c49c..de734e5ea62f23d2396fb03393c32e55d0e1fc7b 100644
--- a/crates/editor/src/display_map/block_map.rs
+++ b/crates/editor/src/display_map/block_map.rs
@@ -128,10 +128,10 @@ impl<T> BlockPlacement<T> {
         }
     }
 
-    fn sort_order(&self) -> u8 {
+    fn tie_break(&self) -> u8 {
         match self {
-            BlockPlacement::Above(_) => 0,
-            BlockPlacement::Replace(_) => 1,
+            BlockPlacement::Replace(_) => 0,
+            BlockPlacement::Above(_) => 1,
             BlockPlacement::Near(_) => 2,
             BlockPlacement::Below(_) => 3,
         }
@@ -143,7 +143,7 @@ impl BlockPlacement<Anchor> {
         self.start()
             .cmp(other.start(), buffer)
             .then_with(|| other.end().cmp(self.end(), buffer))
-            .then_with(|| self.sort_order().cmp(&other.sort_order()))
+            .then_with(|| self.tie_break().cmp(&other.tie_break()))
     }
 
     fn to_wrap_row(&self, wrap_snapshot: &WrapSnapshot) -> Option<BlockPlacement<WrapRow>> {
@@ -847,6 +847,7 @@ impl BlockMap {
                 .start()
                 .cmp(placement_b.start())
                 .then_with(|| placement_b.end().cmp(placement_a.end()))
+                .then_with(|| placement_a.tie_break().cmp(&placement_b.tie_break()))
                 .then_with(|| {
                     if block_a.is_header() {
                         Ordering::Less
@@ -856,7 +857,6 @@ impl BlockMap {
                         Ordering::Equal
                     }
                 })
-                .then_with(|| placement_a.sort_order().cmp(&placement_b.sort_order()))
                 .then_with(|| match (block_a, block_b) {
                     (
                         Block::ExcerptBoundary {
@@ -2922,21 +2922,21 @@ mod tests {
             .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
             .unwrap_or(10);
 
-        let wrap_width = if rng.gen_bool(0.2) {
+        let wrap_width = if rng.random_bool(0.2) {
             None
         } else {
-            Some(px(rng.gen_range(0.0..=100.0)))
+            Some(px(rng.random_range(0.0..=100.0)))
         };
         let tab_size = 1.try_into().unwrap();
         let font_size = px(14.0);
-        let buffer_start_header_height = rng.gen_range(1..=5);
-        let excerpt_header_height = rng.gen_range(1..=5);
+        let buffer_start_header_height = rng.random_range(1..=5);
+        let excerpt_header_height = rng.random_range(1..=5);
 
         log::info!("Wrap width: {:?}", wrap_width);
         log::info!("Excerpt Header Height: {:?}", excerpt_header_height);
-        let is_singleton = rng.r#gen();
+        let is_singleton = rng.random();
         let buffer = if is_singleton {
-            let len = rng.gen_range(0..10);
+            let len = rng.random_range(0..10);
             let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
             log::info!("initial singleton buffer text: {:?}", text);
             cx.update(|cx| MultiBuffer::build_simple(&text, cx))
@@ -2966,30 +2966,30 @@ mod tests {
 
         for _ in 0..operations {
             let mut buffer_edits = Vec::new();
-            match rng.gen_range(0..=100) {
+            match rng.random_range(0..=100) {
                 0..=19 => {
-                    let wrap_width = if rng.gen_bool(0.2) {
+                    let wrap_width = if rng.random_bool(0.2) {
                         None
                     } else {
-                        Some(px(rng.gen_range(0.0..=100.0)))
+                        Some(px(rng.random_range(0.0..=100.0)))
                     };
                     log::info!("Setting wrap width to {:?}", wrap_width);
                     wrap_map.update(cx, |map, cx| map.set_wrap_width(wrap_width, cx));
                 }
                 20..=39 => {
-                    let block_count = rng.gen_range(1..=5);
+                    let block_count = rng.random_range(1..=5);
                     let block_properties = (0..block_count)
                         .map(|_| {
                             let buffer = cx.update(|cx| buffer.read(cx).read(cx).clone());
                             let offset =
-                                buffer.clip_offset(rng.gen_range(0..=buffer.len()), Bias::Left);
+                                buffer.clip_offset(rng.random_range(0..=buffer.len()), Bias::Left);
                             let mut min_height = 0;
-                            let placement = match rng.gen_range(0..3) {
+                            let placement = match rng.random_range(0..3) {
                                 0 => {
                                     min_height = 1;
                                     let start = buffer.anchor_after(offset);
                                     let end = buffer.anchor_after(buffer.clip_offset(
-                                        rng.gen_range(offset..=buffer.len()),
+                                        rng.random_range(offset..=buffer.len()),
                                         Bias::Left,
                                     ));
                                     BlockPlacement::Replace(start..=end)
@@ -2998,7 +2998,7 @@ mod tests {
                                 _ => BlockPlacement::Below(buffer.anchor_after(offset)),
                             };
 
-                            let height = rng.gen_range(min_height..5);
+                            let height = rng.random_range(min_height..5);
                             BlockProperties {
                                 style: BlockStyle::Fixed,
                                 placement,
@@ -3040,7 +3040,7 @@ mod tests {
                     }
                 }
                 40..=59 if !block_map.custom_blocks.is_empty() => {
-                    let block_count = rng.gen_range(1..=4.min(block_map.custom_blocks.len()));
+                    let block_count = rng.random_range(1..=4.min(block_map.custom_blocks.len()));
                     let block_ids_to_remove = block_map
                         .custom_blocks
                         .choose_multiple(&mut rng, block_count)
@@ -3095,8 +3095,8 @@ mod tests {
                     let mut folded_count = folded_buffers.len();
                     let mut unfolded_count = unfolded_buffers.len();
 
-                    let fold = !unfolded_buffers.is_empty() && rng.gen_bool(0.5);
-                    let unfold = !folded_buffers.is_empty() && rng.gen_bool(0.5);
+                    let fold = !unfolded_buffers.is_empty() && rng.random_bool(0.5);
+                    let unfold = !folded_buffers.is_empty() && rng.random_bool(0.5);
                     if !fold && !unfold {
                         log::info!(
                             "Noop fold/unfold operation. Unfolded buffers: {unfolded_count}, folded buffers: {folded_count}"
@@ -3107,7 +3107,7 @@ mod tests {
                     buffer.update(cx, |buffer, cx| {
                         if fold {
                             let buffer_to_fold =
-                                unfolded_buffers[rng.gen_range(0..unfolded_buffers.len())];
+                                unfolded_buffers[rng.random_range(0..unfolded_buffers.len())];
                             log::info!("Folding {buffer_to_fold:?}");
                             let related_excerpts = buffer_snapshot
                                 .excerpts()
@@ -3133,7 +3133,7 @@ mod tests {
                         }
                         if unfold {
                             let buffer_to_unfold =
-                                folded_buffers[rng.gen_range(0..folded_buffers.len())];
+                                folded_buffers[rng.random_range(0..folded_buffers.len())];
                             log::info!("Unfolding {buffer_to_unfold:?}");
                             unfolded_count += 1;
                             folded_count -= 1;
@@ -3146,7 +3146,7 @@ mod tests {
                 }
                 _ => {
                     buffer.update(cx, |buffer, cx| {
-                        let mutation_count = rng.gen_range(1..=5);
+                        let mutation_count = rng.random_range(1..=5);
                         let subscription = buffer.subscribe();
                         buffer.randomly_mutate(&mut rng, mutation_count, cx);
                         buffer_snapshot = buffer.snapshot(cx);
@@ -3331,7 +3331,7 @@ mod tests {
             );
 
             for start_row in 0..expected_row_count {
-                let end_row = rng.gen_range(start_row + 1..=expected_row_count);
+                let end_row = rng.random_range(start_row + 1..=expected_row_count);
                 let mut expected_text = expected_lines[start_row..end_row].join("\n");
                 if end_row < expected_row_count {
                     expected_text.push('\n');
@@ -3426,8 +3426,8 @@ mod tests {
             );
 
             for _ in 0..10 {
-                let end_row = rng.gen_range(1..=expected_lines.len());
-                let start_row = rng.gen_range(0..end_row);
+                let end_row = rng.random_range(1..=expected_lines.len());
+                let start_row = rng.random_range(0..end_row);
 
                 let mut expected_longest_rows_in_range = vec![];
                 let mut longest_line_len_in_range = 0;
diff --git a/crates/editor/src/display_map/fold_map.rs b/crates/editor/src/display_map/fold_map.rs
index 42f46fb74969301007d19032f1b96377d141a724..6d160d0d6d58dbeeac89749aeabcedef6010c1c3 100644
--- a/crates/editor/src/display_map/fold_map.rs
+++ b/crates/editor/src/display_map/fold_map.rs
@@ -1771,9 +1771,9 @@ mod tests {
             .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
             .unwrap_or(10);
 
-        let len = rng.gen_range(0..10);
+        let len = rng.random_range(0..10);
         let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
-        let buffer = if rng.r#gen() {
+        let buffer = if rng.random() {
             MultiBuffer::build_simple(&text, cx)
         } else {
             MultiBuffer::build_random(&mut rng, cx)
@@ -1790,7 +1790,7 @@ mod tests {
             log::info!("text: {:?}", buffer_snapshot.text());
             let mut buffer_edits = Vec::new();
             let mut inlay_edits = Vec::new();
-            match rng.gen_range(0..=100) {
+            match rng.random_range(0..=100) {
                 0..=39 => {
                     snapshot_edits.extend(map.randomly_mutate(&mut rng));
                 }
@@ -1800,7 +1800,7 @@ mod tests {
                 }
                 _ => buffer.update(cx, |buffer, cx| {
                     let subscription = buffer.subscribe();
-                    let edit_count = rng.gen_range(1..=5);
+                    let edit_count = rng.random_range(1..=5);
                     buffer.randomly_mutate(&mut rng, edit_count, cx);
                     buffer_snapshot = buffer.snapshot(cx);
                     let edits = subscription.consume().into_inner();
@@ -1917,10 +1917,14 @@ mod tests {
             }
 
             for _ in 0..5 {
-                let mut start = snapshot
-                    .clip_offset(FoldOffset(rng.gen_range(0..=snapshot.len().0)), Bias::Left);
-                let mut end = snapshot
-                    .clip_offset(FoldOffset(rng.gen_range(0..=snapshot.len().0)), Bias::Right);
+                let mut start = snapshot.clip_offset(
+                    FoldOffset(rng.random_range(0..=snapshot.len().0)),
+                    Bias::Left,
+                );
+                let mut end = snapshot.clip_offset(
+                    FoldOffset(rng.random_range(0..=snapshot.len().0)),
+                    Bias::Right,
+                );
                 if start > end {
                     mem::swap(&mut start, &mut end);
                 }
@@ -1975,8 +1979,8 @@ mod tests {
 
             for _ in 0..5 {
                 let end =
-                    buffer_snapshot.clip_offset(rng.gen_range(0..=buffer_snapshot.len()), Right);
-                let start = buffer_snapshot.clip_offset(rng.gen_range(0..=end), Left);
+                    buffer_snapshot.clip_offset(rng.random_range(0..=buffer_snapshot.len()), Right);
+                let start = buffer_snapshot.clip_offset(rng.random_range(0..=end), Left);
                 let expected_folds = map
                     .snapshot
                     .folds
@@ -2001,10 +2005,10 @@ mod tests {
 
             let text = snapshot.text();
             for _ in 0..5 {
-                let start_row = rng.gen_range(0..=snapshot.max_point().row());
-                let start_column = rng.gen_range(0..=snapshot.line_len(start_row));
-                let end_row = rng.gen_range(0..=snapshot.max_point().row());
-                let end_column = rng.gen_range(0..=snapshot.line_len(end_row));
+                let start_row = rng.random_range(0..=snapshot.max_point().row());
+                let start_column = rng.random_range(0..=snapshot.line_len(start_row));
+                let end_row = rng.random_range(0..=snapshot.max_point().row());
+                let end_column = rng.random_range(0..=snapshot.line_len(end_row));
                 let mut start =
                     snapshot.clip_point(FoldPoint::new(start_row, start_column), Bias::Left);
                 let mut end = snapshot.clip_point(FoldPoint::new(end_row, end_column), Bias::Right);
@@ -2109,17 +2113,17 @@ mod tests {
             rng: &mut impl Rng,
         ) -> Vec<(FoldSnapshot, Vec<FoldEdit>)> {
             let mut snapshot_edits = Vec::new();
-            match rng.gen_range(0..=100) {
+            match rng.random_range(0..=100) {
                 0..=39 if !self.snapshot.folds.is_empty() => {
                     let inlay_snapshot = self.snapshot.inlay_snapshot.clone();
                     let buffer = &inlay_snapshot.buffer;
                     let mut to_unfold = Vec::new();
-                    for _ in 0..rng.gen_range(1..=3) {
-                        let end = buffer.clip_offset(rng.gen_range(0..=buffer.len()), Right);
-                        let start = buffer.clip_offset(rng.gen_range(0..=end), Left);
+                    for _ in 0..rng.random_range(1..=3) {
+                        let end = buffer.clip_offset(rng.random_range(0..=buffer.len()), Right);
+                        let start = buffer.clip_offset(rng.random_range(0..=end), Left);
                         to_unfold.push(start..end);
                     }
-                    let inclusive = rng.r#gen();
+                    let inclusive = rng.random();
                     log::info!("unfolding {:?} (inclusive: {})", to_unfold, inclusive);
                     let (mut writer, snapshot, edits) = self.write(inlay_snapshot, vec![]);
                     snapshot_edits.push((snapshot, edits));
@@ -2130,9 +2134,9 @@ mod tests {
                     let inlay_snapshot = self.snapshot.inlay_snapshot.clone();
                     let buffer = &inlay_snapshot.buffer;
                     let mut to_fold = Vec::new();
-                    for _ in 0..rng.gen_range(1..=2) {
-                        let end = buffer.clip_offset(rng.gen_range(0..=buffer.len()), Right);
-                        let start = buffer.clip_offset(rng.gen_range(0..=end), Left);
+                    for _ in 0..rng.random_range(1..=2) {
+                        let end = buffer.clip_offset(rng.random_range(0..=buffer.len()), Right);
+                        let start = buffer.clip_offset(rng.random_range(0..=end), Left);
                         to_fold.push((start..end, FoldPlaceholder::test()));
                     }
                     log::info!("folding {:?}", to_fold);
diff --git a/crates/editor/src/display_map/inlay_map.rs b/crates/editor/src/display_map/inlay_map.rs
index 3db9d10fdc74f418ecd4ea682dde91185130cd46..e00ffdbf2c6ed7ee7288b2371481cb1f1b28bc92 100644
--- a/crates/editor/src/display_map/inlay_map.rs
+++ b/crates/editor/src/display_map/inlay_map.rs
@@ -719,14 +719,18 @@ impl InlayMap {
         let mut to_remove = Vec::new();
         let mut to_insert = Vec::new();
         let snapshot = &mut self.snapshot;
-        for i in 0..rng.gen_range(1..=5) {
-            if self.inlays.is_empty() || rng.r#gen() {
+        for i in 0..rng.random_range(1..=5) {
+            if self.inlays.is_empty() || rng.random() {
                 let position = snapshot.buffer.random_byte_range(0, rng).start;
-                let bias = if rng.r#gen() { Bias::Left } else { Bias::Right };
-                let len = if rng.gen_bool(0.01) {
+                let bias = if rng.random() {
+                    Bias::Left
+                } else {
+                    Bias::Right
+                };
+                let len = if rng.random_bool(0.01) {
                     0
                 } else {
-                    rng.gen_range(1..=5)
+                    rng.random_range(1..=5)
                 };
                 let text = util::RandomCharIter::new(&mut *rng)
                     .filter(|ch| *ch != '\r')
@@ -1665,8 +1669,8 @@ mod tests {
             .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
             .unwrap_or(10);
 
-        let len = rng.gen_range(0..30);
-        let buffer = if rng.r#gen() {
+        let len = rng.random_range(0..30);
+        let buffer = if rng.random() {
             let text = util::RandomCharIter::new(&mut rng)
                 .take(len)
                 .collect::<String>();
@@ -1683,7 +1687,7 @@ mod tests {
 
             let mut prev_inlay_text = inlay_snapshot.text();
             let mut buffer_edits = Vec::new();
-            match rng.gen_range(0..=100) {
+            match rng.random_range(0..=100) {
                 0..=50 => {
                     let (snapshot, edits) = inlay_map.randomly_mutate(&mut next_inlay_id, &mut rng);
                     log::info!("mutated text: {:?}", snapshot.text());
@@ -1691,7 +1695,7 @@ mod tests {
                 }
                 _ => buffer.update(cx, |buffer, cx| {
                     let subscription = buffer.subscribe();
-                    let edit_count = rng.gen_range(1..=5);
+                    let edit_count = rng.random_range(1..=5);
                     buffer.randomly_mutate(&mut rng, edit_count, cx);
                     buffer_snapshot = buffer.snapshot(cx);
                     let edits = subscription.consume().into_inner();
@@ -1740,7 +1744,7 @@ mod tests {
             }
 
             let mut text_highlights = TextHighlights::default();
-            let text_highlight_count = rng.gen_range(0_usize..10);
+            let text_highlight_count = rng.random_range(0_usize..10);
             let mut text_highlight_ranges = (0..text_highlight_count)
                 .map(|_| buffer_snapshot.random_byte_range(0, &mut rng))
                 .collect::<Vec<_>>();
@@ -1762,10 +1766,10 @@ mod tests {
 
             let mut inlay_highlights = InlayHighlights::default();
             if !inlays.is_empty() {
-                let inlay_highlight_count = rng.gen_range(0..inlays.len());
+                let inlay_highlight_count = rng.random_range(0..inlays.len());
                 let mut inlay_indices = BTreeSet::default();
                 while inlay_indices.len() < inlay_highlight_count {
-                    inlay_indices.insert(rng.gen_range(0..inlays.len()));
+                    inlay_indices.insert(rng.random_range(0..inlays.len()));
                 }
                 let new_highlights = TreeMap::from_ordered_entries(
                     inlay_indices
@@ -1782,8 +1786,8 @@ mod tests {
                                 }),
                                 n => {
                                     let inlay_text = inlay.text.to_string();
-                                    let mut highlight_end = rng.gen_range(1..n);
-                                    let mut highlight_start = rng.gen_range(0..highlight_end);
+                                    let mut highlight_end = rng.random_range(1..n);
+                                    let mut highlight_start = rng.random_range(0..highlight_end);
                                     while !inlay_text.is_char_boundary(highlight_end) {
                                         highlight_end += 1;
                                     }
@@ -1805,9 +1809,9 @@ mod tests {
             }
 
             for _ in 0..5 {
-                let mut end = rng.gen_range(0..=inlay_snapshot.len().0);
+                let mut end = rng.random_range(0..=inlay_snapshot.len().0);
                 end = expected_text.clip_offset(end, Bias::Right);
-                let mut start = rng.gen_range(0..=end);
+                let mut start = rng.random_range(0..=end);
                 start = expected_text.clip_offset(start, Bias::Right);
 
                 let range = InlayOffset(start)..InlayOffset(end);
diff --git a/crates/editor/src/display_map/tab_map.rs b/crates/editor/src/display_map/tab_map.rs
index 6f5df9bb8e658b95260dde4feb2b00c177c98520..523e777d9113b203dafbb5e151ba22a01394c956 100644
--- a/crates/editor/src/display_map/tab_map.rs
+++ b/crates/editor/src/display_map/tab_map.rs
@@ -736,9 +736,9 @@ mod tests {
 
     #[gpui::test(iterations = 100)]
     fn test_random_tabs(cx: &mut gpui::App, mut rng: StdRng) {
-        let tab_size = NonZeroU32::new(rng.gen_range(1..=4)).unwrap();
-        let len = rng.gen_range(0..30);
-        let buffer = if rng.r#gen() {
+        let tab_size = NonZeroU32::new(rng.random_range(1..=4)).unwrap();
+        let len = rng.random_range(0..30);
+        let buffer = if rng.random() {
             let text = util::RandomCharIter::new(&mut rng)
                 .take(len)
                 .collect::<String>();
@@ -769,11 +769,11 @@ mod tests {
         );
 
         for _ in 0..5 {
-            let end_row = rng.gen_range(0..=text.max_point().row);
-            let end_column = rng.gen_range(0..=text.line_len(end_row));
+            let end_row = rng.random_range(0..=text.max_point().row);
+            let end_column = rng.random_range(0..=text.line_len(end_row));
             let mut end = TabPoint(text.clip_point(Point::new(end_row, end_column), Bias::Right));
-            let start_row = rng.gen_range(0..=text.max_point().row);
-            let start_column = rng.gen_range(0..=text.line_len(start_row));
+            let start_row = rng.random_range(0..=text.max_point().row);
+            let start_column = rng.random_range(0..=text.line_len(start_row));
             let mut start =
                 TabPoint(text.clip_point(Point::new(start_row, start_column), Bias::Left));
             if start > end {
diff --git a/crates/editor/src/display_map/wrap_map.rs b/crates/editor/src/display_map/wrap_map.rs
index 500ec3a0bb77f8a8332e86485b81b357644e6d23..127293726a59d1945e8f9dcbfcd2eb3da0cc2290 100644
--- a/crates/editor/src/display_map/wrap_map.rs
+++ b/crates/editor/src/display_map/wrap_map.rs
@@ -1215,12 +1215,12 @@ mod tests {
             .unwrap_or(10);
 
         let text_system = cx.read(|cx| cx.text_system().clone());
-        let mut wrap_width = if rng.gen_bool(0.1) {
+        let mut wrap_width = if rng.random_bool(0.1) {
             None
         } else {
-            Some(px(rng.gen_range(0.0..=1000.0)))
+            Some(px(rng.random_range(0.0..=1000.0)))
         };
-        let tab_size = NonZeroU32::new(rng.gen_range(1..=4)).unwrap();
+        let tab_size = NonZeroU32::new(rng.random_range(1..=4)).unwrap();
 
         let font = test_font();
         let _font_id = text_system.resolve_font(&font);
@@ -1230,10 +1230,10 @@ mod tests {
         log::info!("Wrap width: {:?}", wrap_width);
 
         let buffer = cx.update(|cx| {
-            if rng.r#gen() {
+            if rng.random() {
                 MultiBuffer::build_random(&mut rng, cx)
             } else {
-                let len = rng.gen_range(0..10);
+                let len = rng.random_range(0..10);
                 let text = util::RandomCharIter::new(&mut rng)
                     .take(len)
                     .collect::<String>();
@@ -1281,12 +1281,12 @@ mod tests {
             log::info!("{} ==============================================", _i);
 
             let mut buffer_edits = Vec::new();
-            match rng.gen_range(0..=100) {
+            match rng.random_range(0..=100) {
                 0..=19 => {
-                    wrap_width = if rng.gen_bool(0.2) {
+                    wrap_width = if rng.random_bool(0.2) {
                         None
                     } else {
-                        Some(px(rng.gen_range(0.0..=1000.0)))
+                        Some(px(rng.random_range(0.0..=1000.0)))
                     };
                     log::info!("Setting wrap width to {:?}", wrap_width);
                     wrap_map.update(cx, |map, cx| map.set_wrap_width(wrap_width, cx));
@@ -1317,7 +1317,7 @@ mod tests {
                 _ => {
                     buffer.update(cx, |buffer, cx| {
                         let subscription = buffer.subscribe();
-                        let edit_count = rng.gen_range(1..=5);
+                        let edit_count = rng.random_range(1..=5);
                         buffer.randomly_mutate(&mut rng, edit_count, cx);
                         buffer_snapshot = buffer.snapshot(cx);
                         buffer_edits.extend(subscription.consume());
@@ -1341,7 +1341,7 @@ mod tests {
             snapshot.verify_chunks(&mut rng);
             edits.push((snapshot, wrap_edits));
 
-            if wrap_map.read_with(cx, |map, _| map.is_rewrapping()) && rng.gen_bool(0.4) {
+            if wrap_map.read_with(cx, |map, _| map.is_rewrapping()) && rng.random_bool(0.4) {
                 log::info!("Waiting for wrapping to finish");
                 while wrap_map.read_with(cx, |map, _| map.is_rewrapping()) {
                     notifications.next().await.unwrap();
@@ -1479,8 +1479,8 @@ mod tests {
     impl WrapSnapshot {
         fn verify_chunks(&mut self, rng: &mut impl Rng) {
             for _ in 0..5 {
-                let mut end_row = rng.gen_range(0..=self.max_point().row());
-                let start_row = rng.gen_range(0..=end_row);
+                let mut end_row = rng.random_range(0..=self.max_point().row());
+                let start_row = rng.random_range(0..=end_row);
                 end_row += 1;
 
                 let mut expected_text = self.text_chunks(start_row).collect::<String>();
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index fe5b2f83c2034822d4f36d3b66bbcea3b6b7322c..b54c2c11b1b0553328e4a1a27f380198b20ce55f 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -164,7 +164,7 @@ use project::{
         DiagnosticSeverity, GitGutterSetting, GoToDiagnosticSeverityFilter, ProjectSettings,
     },
 };
-use rand::{seq::SliceRandom, thread_rng};
+use rand::seq::SliceRandom;
 use rpc::{ErrorCode, ErrorExt, proto::PeerId};
 use scroll::{Autoscroll, OngoingScroll, ScrollAnchor, ScrollManager, ScrollbarAutoHide};
 use selections_collection::{
@@ -1030,6 +1030,7 @@ pub struct Editor {
     inline_diagnostics_update: Task<()>,
     inline_diagnostics_enabled: bool,
     diagnostics_enabled: bool,
+    word_completions_enabled: bool,
     inline_diagnostics: Vec<(Anchor, InlineDiagnostic)>,
     soft_wrap_mode_override: Option<language_settings::SoftWrap>,
     hard_wrap: Option<usize>,
@@ -1794,7 +1795,7 @@ impl Editor {
         let font_size = style.font_size.to_pixels(window.rem_size());
         let editor = cx.entity().downgrade();
         let fold_placeholder = FoldPlaceholder {
-            constrain_width: true,
+            constrain_width: false,
             render: Arc::new(move |fold_id, fold_range, cx| {
                 let editor = editor.clone();
                 div()
@@ -2163,6 +2164,7 @@ impl Editor {
             },
             inline_diagnostics_enabled: full_mode,
             diagnostics_enabled: full_mode,
+            word_completions_enabled: full_mode,
             inline_value_cache: InlineValueCache::new(inlay_hint_settings.show_value_hints),
             inlay_hint_cache: InlayHintCache::new(inlay_hint_settings),
             gutter_hovered: false,
@@ -2617,7 +2619,7 @@ impl Editor {
         cx: &mut Context<Workspace>,
     ) -> Task<Result<Entity<Editor>>> {
         let project = workspace.project().clone();
-        let create = project.update(cx, |project, cx| project.create_buffer(cx));
+        let create = project.update(cx, |project, cx| project.create_buffer(true, cx));
 
         cx.spawn_in(window, async move |workspace, cx| {
             let buffer = create.await?;
@@ -2655,7 +2657,7 @@ impl Editor {
         cx: &mut Context<Workspace>,
     ) {
         let project = workspace.project().clone();
-        let create = project.update(cx, |project, cx| project.create_buffer(cx));
+        let create = project.update(cx, |project, cx| project.create_buffer(true, cx));
 
         cx.spawn_in(window, async move |workspace, cx| {
             let buffer = create.await?;
@@ -4892,8 +4894,15 @@ impl Editor {
             });
 
         match completions_source {
-            Some(CompletionsMenuSource::Words) => {
-                self.show_word_completions(&ShowWordCompletions, window, cx)
+            Some(CompletionsMenuSource::Words { .. }) => {
+                self.open_or_update_completions_menu(
+                    Some(CompletionsMenuSource::Words {
+                        ignore_threshold: false,
+                    }),
+                    None,
+                    window,
+                    cx,
+                );
             }
             Some(CompletionsMenuSource::Normal)
             | Some(CompletionsMenuSource::SnippetChoices)
@@ -5401,7 +5410,14 @@ impl Editor {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        self.open_or_update_completions_menu(Some(CompletionsMenuSource::Words), None, window, cx);
+        self.open_or_update_completions_menu(
+            Some(CompletionsMenuSource::Words {
+                ignore_threshold: true,
+            }),
+            None,
+            window,
+            cx,
+        );
     }
 
     pub fn show_completions(
@@ -5450,9 +5466,13 @@ impl Editor {
 
         drop(multibuffer_snapshot);
 
+        let mut ignore_word_threshold = false;
         let provider = match requested_source {
             Some(CompletionsMenuSource::Normal) | None => self.completion_provider.clone(),
-            Some(CompletionsMenuSource::Words) => None,
+            Some(CompletionsMenuSource::Words { ignore_threshold }) => {
+                ignore_word_threshold = ignore_threshold;
+                None
+            }
             Some(CompletionsMenuSource::SnippetChoices) => {
                 log::error!("bug: SnippetChoices requested_source is not handled");
                 None
@@ -5573,10 +5593,12 @@ impl Editor {
             .as_ref()
             .is_none_or(|query| !query.chars().any(|c| c.is_digit(10)));
 
-        let omit_word_completions = match &query {
-            Some(query) => query.chars().count() < completion_settings.words_min_length,
-            None => completion_settings.words_min_length != 0,
-        };
+        let omit_word_completions = !self.word_completions_enabled
+            || (!ignore_word_threshold
+                && match &query {
+                    Some(query) => query.chars().count() < completion_settings.words_min_length,
+                    None => completion_settings.words_min_length != 0,
+                });
 
         let (mut words, provider_responses) = match &provider {
             Some(provider) => {
@@ -10971,7 +10993,7 @@ impl Editor {
     }
 
     pub fn shuffle_lines(&mut self, _: &ShuffleLines, window: &mut Window, cx: &mut Context<Self>) {
-        self.manipulate_immutable_lines(window, cx, |lines| lines.shuffle(&mut thread_rng()))
+        self.manipulate_immutable_lines(window, cx, |lines| lines.shuffle(&mut rand::rng()))
     }
 
     fn manipulate_lines<M>(
@@ -11391,14 +11413,17 @@ impl Editor {
         let mut edits = Vec::new();
         let mut selection_adjustment = 0i32;
 
-        for selection in self.selections.all::<usize>(cx) {
+        for selection in self.selections.all_adjusted(cx) {
             let selection_is_empty = selection.is_empty();
 
             let (start, end) = if selection_is_empty {
                 let (word_range, _) = buffer.surrounding_word(selection.start, false);
                 (word_range.start, word_range.end)
             } else {
-                (selection.start, selection.end)
+                (
+                    buffer.point_to_offset(selection.start),
+                    buffer.point_to_offset(selection.end),
+                )
             };
 
             let text = buffer.text_for_range(start..end).collect::<String>();
@@ -11409,7 +11434,8 @@ impl Editor {
                 start: (start as i32 - selection_adjustment) as usize,
                 end: ((start + text.len()) as i32 - selection_adjustment) as usize,
                 goal: SelectionGoal::None,
-                ..selection
+                id: selection.id,
+                reversed: selection.reversed,
             });
 
             selection_adjustment += old_length - text.len() as i32;
@@ -15112,6 +15138,104 @@ impl Editor {
         });
     }
 
+    pub fn select_next_syntax_node(
+        &mut self,
+        _: &SelectNextSyntaxNode,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let old_selections: Box<[_]> = self.selections.all::<usize>(cx).into();
+        if old_selections.is_empty() {
+            return;
+        }
+
+        self.hide_mouse_cursor(HideMouseCursorOrigin::MovementAction, cx);
+
+        let buffer = self.buffer.read(cx).snapshot(cx);
+        let mut selected_sibling = false;
+
+        let new_selections = old_selections
+            .iter()
+            .map(|selection| {
+                let old_range = selection.start..selection.end;
+
+                if let Some(node) = buffer.syntax_next_sibling(old_range) {
+                    let new_range = node.byte_range();
+                    selected_sibling = true;
+                    Selection {
+                        id: selection.id,
+                        start: new_range.start,
+                        end: new_range.end,
+                        goal: SelectionGoal::None,
+                        reversed: selection.reversed,
+                    }
+                } else {
+                    selection.clone()
+                }
+            })
+            .collect::<Vec<_>>();
+
+        if selected_sibling {
+            self.change_selections(
+                SelectionEffects::scroll(Autoscroll::fit()),
+                window,
+                cx,
+                |s| {
+                    s.select(new_selections);
+                },
+            );
+        }
+    }
+
+    pub fn select_prev_syntax_node(
+        &mut self,
+        _: &SelectPreviousSyntaxNode,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let old_selections: Box<[_]> = self.selections.all::<usize>(cx).into();
+        if old_selections.is_empty() {
+            return;
+        }
+
+        self.hide_mouse_cursor(HideMouseCursorOrigin::MovementAction, cx);
+
+        let buffer = self.buffer.read(cx).snapshot(cx);
+        let mut selected_sibling = false;
+
+        let new_selections = old_selections
+            .iter()
+            .map(|selection| {
+                let old_range = selection.start..selection.end;
+
+                if let Some(node) = buffer.syntax_prev_sibling(old_range) {
+                    let new_range = node.byte_range();
+                    selected_sibling = true;
+                    Selection {
+                        id: selection.id,
+                        start: new_range.start,
+                        end: new_range.end,
+                        goal: SelectionGoal::None,
+                        reversed: selection.reversed,
+                    }
+                } else {
+                    selection.clone()
+                }
+            })
+            .collect::<Vec<_>>();
+
+        if selected_sibling {
+            self.change_selections(
+                SelectionEffects::scroll(Autoscroll::fit()),
+                window,
+                cx,
+                |s| {
+                    s.select(new_selections);
+                },
+            );
+        }
+    }
+
     fn refresh_runnables(&mut self, window: &mut Window, cx: &mut Context<Self>) -> Task<()> {
         if !EditorSettings::get_global(cx).gutter.runnables {
             self.clear_tasks();
@@ -17117,6 +17241,10 @@ impl Editor {
         self.inline_diagnostics.clear();
     }
 
+    pub fn disable_word_completions(&mut self) {
+        self.word_completions_enabled = false;
+    }
+
     pub fn diagnostics_enabled(&self) -> bool {
         self.diagnostics_enabled && self.mode.is_full()
     }
@@ -18968,6 +19096,8 @@ impl Editor {
         }
     }
 
+    /// Returns the project path for the editor's buffer, if any buffer is
+    /// opened in the editor.
     pub fn project_path(&self, cx: &App) -> Option<ProjectPath> {
         if let Some(buffer) = self.buffer.read(cx).as_singleton() {
             buffer.read(cx).project_path(cx)
diff --git a/crates/editor/src/editor_settings.rs b/crates/editor/src/editor_settings.rs
index 44cb0749760e9e3af91bc837df0ef0589e251703..7f4d024e57c4831aa4c512e6dcb3a9ab35d4f610 100644
--- a/crates/editor/src/editor_settings.rs
+++ b/crates/editor/src/editor_settings.rs
@@ -6,7 +6,7 @@ use language::CursorShape;
 use project::project_settings::DiagnosticSeverity;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi, VsCodeSettings};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi, VsCodeSettings};
 use util::serde::default_true;
 
 /// Imports from the VSCode settings at
@@ -431,8 +431,9 @@ pub enum SnippetSortOrder {
     None,
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey)]
 #[settings_ui(group = "Editor")]
+#[settings_key(None)]
 pub struct EditorSettingsContent {
     /// Whether the cursor blinks in the editor.
     ///
@@ -747,6 +748,7 @@ pub struct ScrollbarAxesContent {
 #[derive(
     Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema, PartialEq, Eq, SettingsUi,
 )]
+#[settings_ui(group = "Gutter")]
 pub struct GutterContent {
     /// Whether to show line numbers in the gutter.
     ///
@@ -777,8 +779,6 @@ impl EditorSettings {
 }
 
 impl Settings for EditorSettings {
-    const KEY: Option<&'static str> = None;
-
     type FileContent = EditorSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> anyhow::Result<Self> {
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index 90e488368f99ea50bdcbfc671a359fa5e899f59e..9f578b8b9df374d44c9e9b58e9522489dca66cef 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -5363,6 +5363,20 @@ async fn test_manipulate_text(cx: &mut TestAppContext) {
     cx.assert_editor_state(indoc! {"
         «HeLlO, wOrLD!ˇ»
     "});
+
+    // Test selections with `line_mode = true`.
+    cx.update_editor(|editor, _window, _cx| editor.selections.line_mode = true);
+    cx.set_state(indoc! {"
+        «The quick brown
+        fox jumps over
+        tˇ»he lazy dog
+    "});
+    cx.update_editor(|e, window, cx| e.convert_to_upper_case(&ConvertToUpperCase, window, cx));
+    cx.assert_editor_state(indoc! {"
+        «THE QUICK BROWN
+        FOX JUMPS OVER
+        THE LAZY DOGˇ»
+    "});
 }
 
 #[gpui::test]
@@ -14264,6 +14278,26 @@ async fn test_word_completions_do_not_show_before_threshold(cx: &mut TestAppCont
         }
     });
 
+    cx.update_editor(|editor, window, cx| {
+        editor.show_word_completions(&ShowWordCompletions, window, cx);
+    });
+    cx.executor().run_until_parked();
+    cx.update_editor(|editor, window, cx| {
+        if let Some(CodeContextMenu::Completions(menu)) = editor.context_menu.borrow_mut().as_ref()
+        {
+            assert_eq!(completion_menu_entries(menu), &["wowser", "wowen", "wow"], "Even though the threshold is not met, invoking word completions with an action should provide the completions");
+        } else {
+            panic!("expected completion menu to be open after the word completions are called with an action");
+        }
+
+        editor.cancel(&Cancel, window, cx);
+    });
+    cx.update_editor(|editor, _, _| {
+        if editor.context_menu.borrow_mut().is_some() {
+            panic!("expected completion menu to be hidden after canceling");
+        }
+    });
+
     cx.simulate_keystroke("o");
     cx.executor().run_until_parked();
     cx.update_editor(|editor, _, _| {
@@ -14286,6 +14320,50 @@ async fn test_word_completions_do_not_show_before_threshold(cx: &mut TestAppCont
     });
 }
 
+#[gpui::test]
+async fn test_word_completions_disabled(cx: &mut TestAppContext) {
+    init_test(cx, |language_settings| {
+        language_settings.defaults.completions = Some(CompletionSettings {
+            words: WordsCompletionMode::Enabled,
+            words_min_length: 0,
+            lsp: true,
+            lsp_fetch_timeout_ms: 0,
+            lsp_insert_mode: LspInsertMode::Insert,
+        });
+    });
+
+    let mut cx = EditorLspTestContext::new_rust(lsp::ServerCapabilities::default(), cx).await;
+    cx.update_editor(|editor, _, _| {
+        editor.disable_word_completions();
+    });
+    cx.set_state(indoc! {"ˇ
+        wow
+        wowen
+        wowser
+    "});
+    cx.simulate_keystroke("w");
+    cx.executor().run_until_parked();
+    cx.update_editor(|editor, _, _| {
+        if editor.context_menu.borrow_mut().is_some() {
+            panic!(
+                "expected completion menu to be hidden, as words completion are disabled for this editor"
+            );
+        }
+    });
+
+    cx.update_editor(|editor, window, cx| {
+        editor.show_word_completions(&ShowWordCompletions, window, cx);
+    });
+    cx.executor().run_until_parked();
+    cx.update_editor(|editor, _, _| {
+        if editor.context_menu.borrow_mut().is_some() {
+            panic!(
+                "expected completion menu to be hidden even if called for explicitly, as words completion are disabled for this editor"
+            );
+        }
+    });
+}
+
 fn gen_text_edit(params: &CompletionParams, text: &str) -> Option<lsp::CompletionTextEdit> {
     let position = || lsp::Position {
         line: params.text_document_position.position.line,
@@ -15835,7 +15913,7 @@ async fn test_following(cx: &mut TestAppContext) {
     let project = Project::test(fs, ["/file.rs".as_ref()], cx).await;
 
     let buffer = project.update(cx, |project, cx| {
-        let buffer = project.create_local_buffer(&sample_text(16, 8, 'a'), None, cx);
+        let buffer = project.create_local_buffer(&sample_text(16, 8, 'a'), None, false, cx);
         cx.new(|cx| MultiBuffer::singleton(buffer, cx))
     });
     let leader = cx.add_window(|window, cx| build_editor(buffer.clone(), window, cx));
@@ -16087,8 +16165,8 @@ async fn test_following_with_multiple_excerpts(cx: &mut TestAppContext) {
 
     let (buffer_1, buffer_2) = project.update(cx, |project, cx| {
         (
-            project.create_local_buffer("abc\ndef\nghi\njkl\n", None, cx),
-            project.create_local_buffer("mno\npqr\nstu\nvwx\n", None, cx),
+            project.create_local_buffer("abc\ndef\nghi\njkl\n", None, false, cx),
+            project.create_local_buffer("mno\npqr\nstu\nvwx\n", None, false, cx),
         )
     });
 
@@ -25252,6 +25330,101 @@ async fn test_non_utf_8_opens(cx: &mut TestAppContext) {
     );
 }
 
+#[gpui::test]
+async fn test_select_next_prev_syntax_node(cx: &mut TestAppContext) {
+    init_test(cx, |_| {});
+
+    let language = Arc::new(Language::new(
+        LanguageConfig::default(),
+        Some(tree_sitter_rust::LANGUAGE.into()),
+    ));
+
+    // Test hierarchical sibling navigation
+    let text = r#"
+        fn outer() {
+            if condition {
+                let a = 1;
+            }
+            let b = 2;
+        }
+
+        fn another() {
+            let c = 3;
+        }
+    "#;
+
+    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(language, cx));
+    let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
+    let (editor, cx) = cx.add_window_view(|window, cx| build_editor(buffer, window, cx));
+
+    // Wait for parsing to complete
+    editor
+        .condition::<crate::EditorEvent>(cx, |editor, cx| !editor.buffer.read(cx).is_parsing(cx))
+        .await;
+
+    editor.update_in(cx, |editor, window, cx| {
+        // Start by selecting "let a = 1;" inside the if block
+        editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| {
+            s.select_display_ranges([
+                DisplayPoint::new(DisplayRow(3), 16)..DisplayPoint::new(DisplayRow(3), 26)
+            ]);
+        });
+
+        let initial_selection = editor.selections.display_ranges(cx);
+        assert_eq!(initial_selection.len(), 1, "Should have one selection");
+
+        // Test select next sibling - should move up levels to find the next sibling
+        // Since "let a = 1;" has no siblings in the if block, it should move up
+        // to find "let b = 2;" which is a sibling of the if block
+        editor.select_next_syntax_node(&SelectNextSyntaxNode, window, cx);
+        let next_selection = editor.selections.display_ranges(cx);
+
+        // Should have a selection and it should be different from the initial
+        assert_eq!(
+            next_selection.len(),
+            1,
+            "Should have one selection after next"
+        );
+        assert_ne!(
+            next_selection[0], initial_selection[0],
+            "Next sibling selection should be different"
+        );
+
+        // Test hierarchical navigation by going to the end of the current function
+        // and trying to navigate to the next function
+        editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| {
+            s.select_display_ranges([
+                DisplayPoint::new(DisplayRow(5), 12)..DisplayPoint::new(DisplayRow(5), 22)
+            ]);
+        });
+
+        editor.select_next_syntax_node(&SelectNextSyntaxNode, window, cx);
+        let function_next_selection = editor.selections.display_ranges(cx);
+
+        // Should move to the next function
+        assert_eq!(
+            function_next_selection.len(),
+            1,
+            "Should have one selection after function next"
+        );
+
+        // Test select previous sibling navigation
+        editor.select_prev_syntax_node(&SelectPreviousSyntaxNode, window, cx);
+        let prev_selection = editor.selections.display_ranges(cx);
+
+        // Should have a selection and it should be different
+        assert_eq!(
+            prev_selection.len(),
+            1,
+            "Should have one selection after prev"
+        );
+        assert_ne!(
+            prev_selection[0], function_next_selection[0],
+            "Previous sibling selection should be different from next"
+        );
+    });
+}
+
 #[track_caller]
 fn extract_color_inlays(editor: &Editor, cx: &App) -> Vec<Rgba> {
     editor
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index 9822ec23d5af41ee6fbfdd7c471f6fcc9437c78b..a702d5b74f7d995a8aa29e35fecbed3cadabeba4 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -365,6 +365,8 @@ impl EditorElement {
         register_action(editor, window, Editor::toggle_comments);
         register_action(editor, window, Editor::select_larger_syntax_node);
         register_action(editor, window, Editor::select_smaller_syntax_node);
+        register_action(editor, window, Editor::select_next_syntax_node);
+        register_action(editor, window, Editor::select_prev_syntax_node);
         register_action(editor, window, Editor::unwrap_syntax_node);
         register_action(editor, window, Editor::select_enclosing_symbol);
         register_action(editor, window, Editor::move_to_enclosing_bracket);
@@ -8296,7 +8298,7 @@ impl Element for EditorElement {
                     let (mut snapshot, is_read_only) = self.editor.update(cx, |editor, cx| {
                         (editor.snapshot(window, cx), editor.read_only(cx))
                     });
-                    let style = self.style.clone();
+                    let style = &self.style;
 
                     let rem_size = window.rem_size();
                     let font_id = window.text_system().resolve_font(&style.text.font());
@@ -8771,7 +8773,7 @@ impl Element for EditorElement {
                                     blame.blame_for_rows(&[row_infos], cx).next()
                                 })
                                 .flatten()?;
-                            let mut element = render_inline_blame_entry(blame_entry, &style, cx)?;
+                            let mut element = render_inline_blame_entry(blame_entry, style, cx)?;
                             let inline_blame_padding = ProjectSettings::get_global(cx)
                                 .git
                                 .inline_blame
@@ -8791,7 +8793,7 @@ impl Element for EditorElement {
                     let longest_line_width = layout_line(
                         snapshot.longest_row(),
                         &snapshot,
-                        &style,
+                        style,
                         editor_width,
                         is_row_soft_wrapped,
                         window,
@@ -8949,7 +8951,7 @@ impl Element for EditorElement {
                                 scroll_pixel_position,
                                 newest_selection_head,
                                 editor_width,
-                                &style,
+                                style,
                                 window,
                                 cx,
                             )
@@ -8967,7 +8969,7 @@ impl Element for EditorElement {
                         end_row,
                         line_height,
                         em_width,
-                        &style,
+                        style,
                         window,
                         cx,
                     );
@@ -9112,7 +9114,7 @@ impl Element for EditorElement {
                                     &line_layouts,
                                     newest_selection_head,
                                     newest_selection_point,
-                                    &style,
+                                    style,
                                     window,
                                     cx,
                                 )
diff --git a/crates/editor/src/git/blame.rs b/crates/editor/src/git/blame.rs
index 27a9b8870383b7f1136e31028bacedc8744e0650..51719048ef81cf273bc58e7d810d66d454a04805 100644
--- a/crates/editor/src/git/blame.rs
+++ b/crates/editor/src/git/blame.rs
@@ -1107,7 +1107,7 @@ mod tests {
         init_test(cx);
 
         let fs = FakeFs::new(cx.executor());
-        let buffer_initial_text_len = rng.gen_range(5..15);
+        let buffer_initial_text_len = rng.random_range(5..15);
         let mut buffer_initial_text = Rope::from(
             RandomCharIter::new(&mut rng)
                 .take(buffer_initial_text_len)
@@ -1159,7 +1159,7 @@ mod tests {
         git_blame.update(cx, |blame, cx| blame.check_invariants(cx));
 
         for _ in 0..operations {
-            match rng.gen_range(0..100) {
+            match rng.random_range(0..100) {
                 0..=19 => {
                     log::info!("quiescing");
                     cx.executor().run_until_parked();
@@ -1202,8 +1202,8 @@ mod tests {
         let mut blame_entries = Vec::new();
         for ix in 0..5 {
             if last_row < max_row {
-                let row_start = rng.gen_range(last_row..max_row);
-                let row_end = rng.gen_range(row_start + 1..cmp::min(row_start + 3, max_row) + 1);
+                let row_start = rng.random_range(last_row..max_row);
+                let row_end = rng.random_range(row_start + 1..cmp::min(row_start + 3, max_row) + 1);
                 blame_entries.push(blame_entry(&ix.to_string(), row_start..row_end));
                 last_row = row_end;
             } else {
diff --git a/crates/editor/src/items.rs b/crates/editor/src/items.rs
index 8a07939cf47529d6a7d94b20bd22d7278b3e9d24..253d0c27518107dc1cad3733cefbfef5bc12b807 100644
--- a/crates/editor/src/items.rs
+++ b/crates/editor/src/items.rs
@@ -651,7 +651,8 @@ impl Item for Editor {
         if let Some(path) = path_for_buffer(&self.buffer, detail, true, cx) {
             path.to_string_lossy().to_string().into()
         } else {
-            "untitled".into()
+            // Use the same logic as the displayed title for consistency
+            self.buffer.read(cx).title(cx).to_string().into()
         }
     }
 
@@ -1129,7 +1130,7 @@ impl SerializableItem for Editor {
 
                     // First create the empty buffer
                     let buffer = project
-                        .update(cx, |project, cx| project.create_buffer(cx))?
+                        .update(cx, |project, cx| project.create_buffer(true, cx))?
                         .await?;
 
                     // Then set the text so that the dirty bit is set correctly
@@ -1237,7 +1238,7 @@ impl SerializableItem for Editor {
                 ..
             } => window.spawn(cx, async move |cx| {
                 let buffer = project
-                    .update(cx, |project, cx| project.create_buffer(cx))?
+                    .update(cx, |project, cx| project.create_buffer(true, cx))?
                     .await?;
 
                 cx.update(|window, cx| {
diff --git a/crates/editor/src/movement.rs b/crates/editor/src/movement.rs
index 216bea169683409b219641cc3496de9280bb05f6..4bd353a2873431d8102dfc15dea9a74ac2b2c241 100644
--- a/crates/editor/src/movement.rs
+++ b/crates/editor/src/movement.rs
@@ -4,7 +4,7 @@
 use super::{Bias, DisplayPoint, DisplaySnapshot, SelectionGoal, ToDisplayPoint};
 use crate::{DisplayRow, EditorStyle, ToOffset, ToPoint, scroll::ScrollAnchor};
 use gpui::{Pixels, WindowTextSystem};
-use language::Point;
+use language::{CharClassifier, Point};
 use multi_buffer::{MultiBufferRow, MultiBufferSnapshot};
 use serde::Deserialize;
 use workspace::searchable::Direction;
@@ -405,15 +405,18 @@ pub fn previous_subword_start(map: &DisplaySnapshot, point: DisplayPoint) -> Dis
     let classifier = map.buffer_snapshot.char_classifier_at(raw_point);
 
     find_preceding_boundary_display_point(map, point, FindRange::MultiLine, |left, right| {
-        let is_word_start =
-            classifier.kind(left) != classifier.kind(right) && !right.is_whitespace();
-        let is_subword_start = classifier.is_word('-') && left == '-' && right != '-'
-            || left == '_' && right != '_'
-            || left.is_lowercase() && right.is_uppercase();
-        is_word_start || is_subword_start || left == '\n'
+        is_subword_start(left, right, &classifier) || left == '\n'
     })
 }
 
+pub fn is_subword_start(left: char, right: char, classifier: &CharClassifier) -> bool {
+    let is_word_start = classifier.kind(left) != classifier.kind(right) && !right.is_whitespace();
+    let is_subword_start = classifier.is_word('-') && left == '-' && right != '-'
+        || left == '_' && right != '_'
+        || left.is_lowercase() && right.is_uppercase();
+    is_word_start || is_subword_start
+}
+
 /// Returns a position of the next word boundary, where a word character is defined as either
 /// uppercase letter, lowercase letter, '_' character or language-specific word character (like '-' in CSS).
 pub fn next_word_end(map: &DisplaySnapshot, point: DisplayPoint) -> DisplayPoint {
@@ -463,15 +466,19 @@ pub fn next_subword_end(map: &DisplaySnapshot, point: DisplayPoint) -> DisplayPo
     let classifier = map.buffer_snapshot.char_classifier_at(raw_point);
 
     find_boundary(map, point, FindRange::MultiLine, |left, right| {
-        let is_word_end =
-            (classifier.kind(left) != classifier.kind(right)) && !classifier.is_whitespace(left);
-        let is_subword_end = classifier.is_word('-') && left != '-' && right == '-'
-            || left != '_' && right == '_'
-            || left.is_lowercase() && right.is_uppercase();
-        is_word_end || is_subword_end || right == '\n'
+        is_subword_end(left, right, &classifier) || right == '\n'
     })
 }
 
+pub fn is_subword_end(left: char, right: char, classifier: &CharClassifier) -> bool {
+    let is_word_end =
+        (classifier.kind(left) != classifier.kind(right)) && !classifier.is_whitespace(left);
+    let is_subword_end = classifier.is_word('-') && left != '-' && right == '-'
+        || left != '_' && right == '_'
+        || left.is_lowercase() && right.is_uppercase();
+    is_word_end || is_subword_end
+}
+
 /// Returns a position of the start of the current paragraph, where a paragraph
 /// is defined as a run of non-blank lines.
 pub fn start_of_paragraph(
diff --git a/crates/editor/src/rust_analyzer_ext.rs b/crates/editor/src/rust_analyzer_ext.rs
index cf74ee0a9eb5f6baaf6b1a1289173bbc3e173719..f4059ca03d2ad70106aa958b4fe0c545cb4988ea 100644
--- a/crates/editor/src/rust_analyzer_ext.rs
+++ b/crates/editor/src/rust_analyzer_ext.rs
@@ -200,7 +200,7 @@ pub fn expand_macro_recursively(
         }
 
         let buffer = project
-            .update(cx, |project, cx| project.create_buffer(cx))?
+            .update(cx, |project, cx| project.create_buffer(false, cx))?
             .await?;
         workspace.update_in(cx, |workspace, window, cx| {
             buffer.update(cx, |buffer, cx| {
diff --git a/crates/extension_host/src/extension_settings.rs b/crates/extension_host/src/extension_settings.rs
index 6bd760795cec6d1c4208770f1355e8ac7a34eb95..fa5a613c55a76a0b5660b114d49acc17fcf79120 100644
--- a/crates/extension_host/src/extension_settings.rs
+++ b/crates/extension_host/src/extension_settings.rs
@@ -3,10 +3,11 @@ use collections::HashMap;
 use gpui::App;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 use std::sync::Arc;
 
-#[derive(Deserialize, Serialize, Debug, Default, Clone, JsonSchema, SettingsUi)]
+#[derive(Deserialize, Serialize, Debug, Default, Clone, JsonSchema, SettingsUi, SettingsKey)]
+#[settings_key(None)]
 pub struct ExtensionSettings {
     /// The extensions that should be automatically installed by Zed.
     ///
@@ -38,8 +39,6 @@ impl ExtensionSettings {
 }
 
 impl Settings for ExtensionSettings {
-    const KEY: Option<&'static str> = None;
-
     type FileContent = Self;
 
     fn load(sources: SettingsSources<Self::FileContent>, _cx: &mut App) -> Result<Self> {
diff --git a/crates/extensions_ui/src/extensions_ui.rs b/crates/extensions_ui/src/extensions_ui.rs
index fd504764b65826ea74e092ea4c11d5576fa51524..0b925dceb1544d97a77082881626bc1e97f3d1b0 100644
--- a/crates/extensions_ui/src/extensions_ui.rs
+++ b/crates/extensions_ui/src/extensions_ui.rs
@@ -1345,7 +1345,7 @@ impl ExtensionsPage {
                             this.update_settings::<VimModeSetting>(
                                 selection,
                                 cx,
-                                |setting, value| *setting = Some(value),
+                                |setting, value| setting.vim_mode = Some(value),
                             );
                         }),
                     )),
diff --git a/crates/feature_flags/src/feature_flags.rs b/crates/feature_flags/src/feature_flags.rs
index b9e9f3ae9f36ecaa7cf4f4c7a41dc8ccab973730..8a50b7ec9bcc5149360ad7499e5e97d5731dfaa7 100644
--- a/crates/feature_flags/src/feature_flags.rs
+++ b/crates/feature_flags/src/feature_flags.rs
@@ -66,9 +66,10 @@ impl FeatureFlag for LlmClosedBetaFeatureFlag {
     const NAME: &'static str = "llm-closed-beta";
 }
 
-pub struct ZedProFeatureFlag {}
-impl FeatureFlag for ZedProFeatureFlag {
-    const NAME: &'static str = "zed-pro";
+pub struct BillingV2FeatureFlag {}
+
+impl FeatureFlag for BillingV2FeatureFlag {
+    const NAME: &'static str = "billing-v2";
 }
 
 pub struct NotebookFeatureFlag;
diff --git a/crates/file_finder/src/file_finder_settings.rs b/crates/file_finder/src/file_finder_settings.rs
index 007af53b1144ed4caa7985d75cdf4707f13ed13e..6a6b98b8ea3e1c7e7f0e3cc0385fdd7f413b659f 100644
--- a/crates/file_finder/src/file_finder_settings.rs
+++ b/crates/file_finder/src/file_finder_settings.rs
@@ -1,7 +1,7 @@
 use anyhow::Result;
 use schemars::JsonSchema;
 use serde_derive::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 
 #[derive(Deserialize, Debug, Clone, Copy, PartialEq)]
 pub struct FileFinderSettings {
@@ -11,7 +11,8 @@ pub struct FileFinderSettings {
     pub include_ignored: Option<bool>,
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi, SettingsKey)]
+#[settings_key(key = "file_finder")]
 pub struct FileFinderSettingsContent {
     /// Whether to show file icons in the file finder.
     ///
@@ -42,8 +43,6 @@ pub struct FileFinderSettingsContent {
 }
 
 impl Settings for FileFinderSettings {
-    const KEY: Option<&'static str> = Some("file_finder");
-
     type FileContent = FileFinderSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut gpui::App) -> Result<Self> {
diff --git a/crates/file_finder/src/open_path_prompt.rs b/crates/file_finder/src/open_path_prompt.rs
index 4625872e46c690701b304351c6648a8e380f181a..c0abb372b28ff817853e9dc7b6523f676359e157 100644
--- a/crates/file_finder/src/open_path_prompt.rs
+++ b/crates/file_finder/src/open_path_prompt.rs
@@ -1,7 +1,7 @@
 use crate::file_finder_settings::FileFinderSettings;
 use file_icons::FileIcons;
 use futures::channel::oneshot;
-use fuzzy::{StringMatch, StringMatchCandidate};
+use fuzzy::{CharBag, StringMatch, StringMatchCandidate};
 use gpui::{HighlightStyle, StyledText, Task};
 use picker::{Picker, PickerDelegate};
 use project::{DirectoryItem, DirectoryLister};
@@ -23,7 +23,6 @@ use workspace::Workspace;
 
 pub(crate) struct OpenPathPrompt;
 
-#[derive(Debug)]
 pub struct OpenPathDelegate {
     tx: Option<oneshot::Sender<Option<Vec<PathBuf>>>>,
     lister: DirectoryLister,
@@ -35,6 +34,9 @@ pub struct OpenPathDelegate {
     prompt_root: String,
     path_style: PathStyle,
     replace_prompt: Task<()>,
+    render_footer:
+        Arc<dyn Fn(&mut Window, &mut Context<Picker<Self>>) -> Option<AnyElement> + 'static>,
+    hidden_entries: bool,
 }
 
 impl OpenPathDelegate {
@@ -60,9 +62,25 @@ impl OpenPathDelegate {
             },
             path_style,
             replace_prompt: Task::ready(()),
+            render_footer: Arc::new(|_, _| None),
+            hidden_entries: false,
         }
     }
 
+    pub fn with_footer(
+        mut self,
+        footer: Arc<
+            dyn Fn(&mut Window, &mut Context<Picker<Self>>) -> Option<AnyElement> + 'static,
+        >,
+    ) -> Self {
+        self.render_footer = footer;
+        self
+    }
+
+    pub fn show_hidden(mut self) -> Self {
+        self.hidden_entries = true;
+        self
+    }
     fn get_entry(&self, selected_match_index: usize) -> Option<CandidateInfo> {
         match &self.directory_state {
             DirectoryState::List { entries, .. } => {
@@ -125,6 +143,13 @@ impl OpenPathDelegate {
             DirectoryState::None { .. } => Vec::new(),
         }
     }
+
+    fn current_dir(&self) -> &'static str {
+        match self.path_style {
+            PathStyle::Posix => "./",
+            PathStyle::Windows => ".\\",
+        }
+    }
 }
 
 #[derive(Debug)]
@@ -233,6 +258,7 @@ impl PickerDelegate for OpenPathDelegate {
         cx: &mut Context<Picker<Self>>,
     ) -> Task<()> {
         let lister = &self.lister;
+        let input_is_empty = query.is_empty();
         let (dir, suffix) = get_dir_and_suffix(query, self.path_style);
 
         let query = match &self.directory_state {
@@ -261,8 +287,9 @@ impl PickerDelegate for OpenPathDelegate {
         self.cancel_flag.store(true, atomic::Ordering::Release);
         self.cancel_flag = Arc::new(AtomicBool::new(false));
         let cancel_flag = self.cancel_flag.clone();
-
+        let hidden_entries = self.hidden_entries;
         let parent_path_is_root = self.prompt_root == dir;
+        let current_dir = self.current_dir();
         cx.spawn_in(window, async move |this, cx| {
             if let Some(query) = query {
                 let paths = query.await;
@@ -353,10 +380,38 @@ impl PickerDelegate for OpenPathDelegate {
                 return;
             };
 
-            if !suffix.starts_with('.') {
-                new_entries.retain(|entry| !entry.path.string.starts_with('.'));
+            let mut max_id = 0;
+            if !suffix.starts_with('.') && !hidden_entries {
+                new_entries.retain(|entry| {
+                    max_id = max_id.max(entry.path.id);
+                    !entry.path.string.starts_with('.')
+                });
             }
+
             if suffix.is_empty() {
+                let should_prepend_with_current_dir = this
+                    .read_with(cx, |picker, _| {
+                        !input_is_empty
+                            && !matches!(
+                                picker.delegate.directory_state,
+                                DirectoryState::Create { .. }
+                            )
+                    })
+                    .unwrap_or(false);
+                if should_prepend_with_current_dir {
+                    new_entries.insert(
+                        0,
+                        CandidateInfo {
+                            path: StringMatchCandidate {
+                                id: max_id + 1,
+                                string: current_dir.to_string(),
+                                char_bag: CharBag::from(current_dir),
+                            },
+                            is_dir: true,
+                        },
+                    );
+                }
+
                 this.update(cx, |this, cx| {
                     this.delegate.selected_index = 0;
                     this.delegate.string_matches = new_entries
@@ -485,6 +540,10 @@ impl PickerDelegate for OpenPathDelegate {
         _: &mut Context<Picker<Self>>,
     ) -> Option<String> {
         let candidate = self.get_entry(self.selected_index)?;
+        if candidate.path.string.is_empty() || candidate.path.string == self.current_dir() {
+            return None;
+        }
+
         let path_style = self.path_style;
         Some(
             maybe!({
@@ -629,12 +688,18 @@ impl PickerDelegate for OpenPathDelegate {
             DirectoryState::None { .. } => Vec::new(),
         };
 
+        let is_current_dir_candidate = candidate.path.string == self.current_dir();
+
         let file_icon = maybe!({
             if !settings.file_icons {
                 return None;
             }
             let icon = if candidate.is_dir {
-                FileIcons::get_folder_icon(false, cx)?
+                if is_current_dir_candidate {
+                    return Some(Icon::new(IconName::ReplyArrowRight).color(Color::Muted));
+                } else {
+                    FileIcons::get_folder_icon(false, cx)?
+                }
             } else {
                 let path = path::Path::new(&candidate.path.string);
                 FileIcons::get_icon(path, cx)?
@@ -652,6 +717,8 @@ impl PickerDelegate for OpenPathDelegate {
                     .child(HighlightedLabel::new(
                         if parent_path == &self.prompt_root {
                             format!("{}{}", self.prompt_root, candidate.path.string)
+                        } else if is_current_dir_candidate {
+                            "open this directory".to_string()
                         } else {
                             candidate.path.string
                         },
@@ -732,6 +799,14 @@ impl PickerDelegate for OpenPathDelegate {
         }
     }
 
+    fn render_footer(
+        &self,
+        window: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> Option<AnyElement> {
+        (self.render_footer)(window, cx)
+    }
+
     fn no_matches_text(&self, _window: &mut Window, _cx: &mut App) -> Option<SharedString> {
         Some(match &self.directory_state {
             DirectoryState::Create { .. } => SharedString::from("Type a path…"),
@@ -747,6 +822,17 @@ impl PickerDelegate for OpenPathDelegate {
     fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
         Arc::from(format!("[directory{MAIN_SEPARATOR_STR}]filename.ext"))
     }
+
+    fn separators_after_indices(&self) -> Vec<usize> {
+        let Some(m) = self.string_matches.first() else {
+            return Vec::new();
+        };
+        if m.string == self.current_dir() {
+            vec![0]
+        } else {
+            Vec::new()
+        }
+    }
 }
 
 fn path_candidates(
diff --git a/crates/file_finder/src/open_path_prompt_tests.rs b/crates/file_finder/src/open_path_prompt_tests.rs
index a69ac6992dc280fd6537b16087302c2fbb9f8f4c..1f47c4e80adc598c505cf130519623fd6e578035 100644
--- a/crates/file_finder/src/open_path_prompt_tests.rs
+++ b/crates/file_finder/src/open_path_prompt_tests.rs
@@ -43,12 +43,17 @@ async fn test_open_path_prompt(cx: &mut TestAppContext) {
     insert_query(query, &picker, cx).await;
     assert_eq!(collect_match_candidates(&picker, cx), vec!["root"]);
 
+    #[cfg(not(windows))]
+    let expected_separator = "./";
+    #[cfg(windows)]
+    let expected_separator = ".\\";
+
     // If the query ends with a slash, the picker should show the contents of the directory.
     let query = path!("/root/");
     insert_query(query, &picker, cx).await;
     assert_eq!(
         collect_match_candidates(&picker, cx),
-        vec!["a1", "a2", "a3", "dir1", "dir2"]
+        vec![expected_separator, "a1", "a2", "a3", "dir1", "dir2"]
     );
 
     // Show candidates for the query "a".
@@ -72,7 +77,7 @@ async fn test_open_path_prompt(cx: &mut TestAppContext) {
     insert_query(query, &picker, cx).await;
     assert_eq!(
         collect_match_candidates(&picker, cx),
-        vec!["c", "d1", "d2", "d3", "dir3", "dir4"]
+        vec![expected_separator, "c", "d1", "d2", "d3", "dir3", "dir4"]
     );
 
     // Show candidates for the query "d".
@@ -116,71 +121,86 @@ async fn test_open_path_prompt_completion(cx: &mut TestAppContext) {
     // Confirm completion for the query "/root", since it's a directory, it should add a trailing slash.
     let query = path!("/root");
     insert_query(query, &picker, cx).await;
-    assert_eq!(confirm_completion(query, 0, &picker, cx), path!("/root/"));
+    assert_eq!(
+        confirm_completion(query, 0, &picker, cx).unwrap(),
+        path!("/root/")
+    );
 
     // Confirm completion for the query "/root/", selecting the first candidate "a", since it's a file, it should not add a trailing slash.
     let query = path!("/root/");
     insert_query(query, &picker, cx).await;
-    assert_eq!(confirm_completion(query, 0, &picker, cx), path!("/root/a"));
+    assert_eq!(
+        confirm_completion(query, 0, &picker, cx),
+        None,
+        "First entry is `./` and when we confirm completion, it is tabbed below"
+    );
+    assert_eq!(
+        confirm_completion(query, 1, &picker, cx).unwrap(),
+        path!("/root/a"),
+        "Second entry is the first entry of a directory that we want to be completed"
+    );
 
     // Confirm completion for the query "/root/", selecting the second candidate "dir1", since it's a directory, it should add a trailing slash.
     let query = path!("/root/");
     insert_query(query, &picker, cx).await;
     assert_eq!(
-        confirm_completion(query, 1, &picker, cx),
+        confirm_completion(query, 2, &picker, cx).unwrap(),
         path!("/root/dir1/")
     );
 
     let query = path!("/root/a");
     insert_query(query, &picker, cx).await;
-    assert_eq!(confirm_completion(query, 0, &picker, cx), path!("/root/a"));
+    assert_eq!(
+        confirm_completion(query, 0, &picker, cx).unwrap(),
+        path!("/root/a")
+    );
 
     let query = path!("/root/d");
     insert_query(query, &picker, cx).await;
     assert_eq!(
-        confirm_completion(query, 1, &picker, cx),
+        confirm_completion(query, 1, &picker, cx).unwrap(),
         path!("/root/dir2/")
     );
 
     let query = path!("/root/dir2");
     insert_query(query, &picker, cx).await;
     assert_eq!(
-        confirm_completion(query, 0, &picker, cx),
+        confirm_completion(query, 0, &picker, cx).unwrap(),
         path!("/root/dir2/")
     );
 
     let query = path!("/root/dir2/");
     insert_query(query, &picker, cx).await;
     assert_eq!(
-        confirm_completion(query, 0, &picker, cx),
+        confirm_completion(query, 1, &picker, cx).unwrap(),
         path!("/root/dir2/c")
     );
 
     let query = path!("/root/dir2/");
     insert_query(query, &picker, cx).await;
     assert_eq!(
-        confirm_completion(query, 2, &picker, cx),
+        confirm_completion(query, 3, &picker, cx).unwrap(),
         path!("/root/dir2/dir3/")
     );
 
     let query = path!("/root/dir2/d");
     insert_query(query, &picker, cx).await;
     assert_eq!(
-        confirm_completion(query, 0, &picker, cx),
+        confirm_completion(query, 0, &picker, cx).unwrap(),
         path!("/root/dir2/d")
     );
 
     let query = path!("/root/dir2/d");
     insert_query(query, &picker, cx).await;
     assert_eq!(
-        confirm_completion(query, 1, &picker, cx),
+        confirm_completion(query, 1, &picker, cx).unwrap(),
         path!("/root/dir2/dir3/")
     );
 
     let query = path!("/root/dir2/di");
     insert_query(query, &picker, cx).await;
     assert_eq!(
-        confirm_completion(query, 1, &picker, cx),
+        confirm_completion(query, 1, &picker, cx).unwrap(),
         path!("/root/dir2/dir4/")
     );
 }
@@ -211,42 +231,63 @@ async fn test_open_path_prompt_on_windows(cx: &mut TestAppContext) {
     insert_query(query, &picker, cx).await;
     assert_eq!(
         collect_match_candidates(&picker, cx),
-        vec!["a", "dir1", "dir2"]
+        vec![".\\", "a", "dir1", "dir2"]
+    );
+    assert_eq!(
+        confirm_completion(query, 0, &picker, cx),
+        None,
+        "First entry is `.\\` and when we confirm completion, it is tabbed below"
+    );
+    assert_eq!(
+        confirm_completion(query, 1, &picker, cx).unwrap(),
+        "C:/root/a",
+        "Second entry is the first entry of a directory that we want to be completed"
     );
-    assert_eq!(confirm_completion(query, 0, &picker, cx), "C:/root/a");
 
     let query = "C:\\root/";
     insert_query(query, &picker, cx).await;
     assert_eq!(
         collect_match_candidates(&picker, cx),
-        vec!["a", "dir1", "dir2"]
+        vec![".\\", "a", "dir1", "dir2"]
+    );
+    assert_eq!(
+        confirm_completion(query, 1, &picker, cx).unwrap(),
+        "C:\\root/a"
     );
-    assert_eq!(confirm_completion(query, 0, &picker, cx), "C:\\root/a");
 
     let query = "C:\\root\\";
     insert_query(query, &picker, cx).await;
     assert_eq!(
         collect_match_candidates(&picker, cx),
-        vec!["a", "dir1", "dir2"]
+        vec![".\\", "a", "dir1", "dir2"]
+    );
+    assert_eq!(
+        confirm_completion(query, 1, &picker, cx).unwrap(),
+        "C:\\root\\a"
     );
-    assert_eq!(confirm_completion(query, 0, &picker, cx), "C:\\root\\a");
 
     // Confirm completion for the query "C:/root/d", selecting the second candidate "dir2", since it's a directory, it should add a trailing slash.
     let query = "C:/root/d";
     insert_query(query, &picker, cx).await;
     assert_eq!(collect_match_candidates(&picker, cx), vec!["dir1", "dir2"]);
-    assert_eq!(confirm_completion(query, 1, &picker, cx), "C:/root/dir2\\");
+    assert_eq!(
+        confirm_completion(query, 1, &picker, cx).unwrap(),
+        "C:/root/dir2\\"
+    );
 
     let query = "C:\\root/d";
     insert_query(query, &picker, cx).await;
     assert_eq!(collect_match_candidates(&picker, cx), vec!["dir1", "dir2"]);
-    assert_eq!(confirm_completion(query, 0, &picker, cx), "C:\\root/dir1\\");
+    assert_eq!(
+        confirm_completion(query, 0, &picker, cx).unwrap(),
+        "C:\\root/dir1\\"
+    );
 
     let query = "C:\\root\\d";
     insert_query(query, &picker, cx).await;
     assert_eq!(collect_match_candidates(&picker, cx), vec!["dir1", "dir2"]);
     assert_eq!(
-        confirm_completion(query, 0, &picker, cx),
+        confirm_completion(query, 0, &picker, cx).unwrap(),
         "C:\\root\\dir1\\"
     );
 }
@@ -276,20 +317,29 @@ async fn test_open_path_prompt_on_windows_with_remote(cx: &mut TestAppContext) {
     insert_query(query, &picker, cx).await;
     assert_eq!(
         collect_match_candidates(&picker, cx),
-        vec!["a", "dir1", "dir2"]
+        vec!["./", "a", "dir1", "dir2"]
+    );
+    assert_eq!(
+        confirm_completion(query, 1, &picker, cx).unwrap(),
+        "/root/a"
     );
-    assert_eq!(confirm_completion(query, 0, &picker, cx), "/root/a");
 
     // Confirm completion for the query "/root/d", selecting the second candidate "dir2", since it's a directory, it should add a trailing slash.
     let query = "/root/d";
     insert_query(query, &picker, cx).await;
     assert_eq!(collect_match_candidates(&picker, cx), vec!["dir1", "dir2"]);
-    assert_eq!(confirm_completion(query, 1, &picker, cx), "/root/dir2/");
+    assert_eq!(
+        confirm_completion(query, 1, &picker, cx).unwrap(),
+        "/root/dir2/"
+    );
 
     let query = "/root/d";
     insert_query(query, &picker, cx).await;
     assert_eq!(collect_match_candidates(&picker, cx), vec!["dir1", "dir2"]);
-    assert_eq!(confirm_completion(query, 0, &picker, cx), "/root/dir1/");
+    assert_eq!(
+        confirm_completion(query, 0, &picker, cx).unwrap(),
+        "/root/dir1/"
+    );
 }
 
 #[gpui::test]
@@ -396,15 +446,13 @@ fn confirm_completion(
     select: usize,
     picker: &Entity<Picker<OpenPathDelegate>>,
     cx: &mut VisualTestContext,
-) -> String {
-    picker
-        .update_in(cx, |f, window, cx| {
-            if f.delegate.selected_index() != select {
-                f.delegate.set_selected_index(select, window, cx);
-            }
-            f.delegate.confirm_completion(query.to_string(), window, cx)
-        })
-        .unwrap()
+) -> Option<String> {
+    picker.update_in(cx, |f, window, cx| {
+        if f.delegate.selected_index() != select {
+            f.delegate.set_selected_index(select, window, cx);
+        }
+        f.delegate.confirm_completion(query.to_string(), window, cx)
+    })
 }
 
 fn collect_match_candidates(
diff --git a/crates/fs/src/fs.rs b/crates/fs/src/fs.rs
index a5cf9b88254deff5b9a07402207f19875827d7f0..98c8dc9054984c49732bec57a9604a14ceb5ee72 100644
--- a/crates/fs/src/fs.rs
+++ b/crates/fs/src/fs.rs
@@ -20,6 +20,9 @@ use std::os::fd::{AsFd, AsRawFd};
 #[cfg(unix)]
 use std::os::unix::fs::{FileTypeExt, MetadataExt};
 
+#[cfg(any(target_os = "macos", target_os = "freebsd"))]
+use std::mem::MaybeUninit;
+
 use async_tar::Archive;
 use futures::{AsyncRead, Stream, StreamExt, future::BoxFuture};
 use git::repository::{GitRepository, RealGitRepository};
@@ -261,14 +264,15 @@ impl FileHandle for std::fs::File {
         };
 
         let fd = self.as_fd();
-        let mut path_buf: [libc::c_char; libc::PATH_MAX as usize] = [0; libc::PATH_MAX as usize];
+        let mut path_buf = MaybeUninit::<[u8; libc::PATH_MAX as usize]>::uninit();
 
         let result = unsafe { libc::fcntl(fd.as_raw_fd(), libc::F_GETPATH, path_buf.as_mut_ptr()) };
         if result == -1 {
             anyhow::bail!("fcntl returned -1".to_string());
         }
 
-        let c_str = unsafe { CStr::from_ptr(path_buf.as_ptr()) };
+        // SAFETY: `fcntl` will initialize the path buffer.
+        let c_str = unsafe { CStr::from_ptr(path_buf.as_ptr().cast()) };
         let path = PathBuf::from(OsStr::from_bytes(c_str.to_bytes()));
         Ok(path)
     }
@@ -296,15 +300,16 @@ impl FileHandle for std::fs::File {
         };
 
         let fd = self.as_fd();
-        let mut kif: libc::kinfo_file = unsafe { std::mem::zeroed() };
+        let mut kif = MaybeUninit::<libc::kinfo_file>::uninit();
         kif.kf_structsize = libc::KINFO_FILE_SIZE;
 
-        let result = unsafe { libc::fcntl(fd.as_raw_fd(), libc::F_KINFO, &mut kif) };
+        let result = unsafe { libc::fcntl(fd.as_raw_fd(), libc::F_KINFO, kif.as_mut_ptr()) };
         if result == -1 {
             anyhow::bail!("fcntl returned -1".to_string());
         }
 
-        let c_str = unsafe { CStr::from_ptr(kif.kf_path.as_ptr()) };
+        // SAFETY: `fcntl` will initialize the kif.
+        let c_str = unsafe { CStr::from_ptr(kif.assume_init().kf_path.as_ptr()) };
         let path = PathBuf::from(OsStr::from_bytes(c_str.to_bytes()));
         Ok(path)
     }
diff --git a/crates/git_hosting_providers/src/settings.rs b/crates/git_hosting_providers/src/settings.rs
index 34e3805a39ea8a13a6a2f79552a6a917c4597692..3249981db91015479bab728484341519db357683 100644
--- a/crates/git_hosting_providers/src/settings.rs
+++ b/crates/git_hosting_providers/src/settings.rs
@@ -5,7 +5,7 @@ use git::GitHostingProviderRegistry;
 use gpui::App;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsStore, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsStore, SettingsUi};
 use url::Url;
 use util::ResultExt as _;
 
@@ -78,7 +78,8 @@ pub struct GitHostingProviderConfig {
     pub name: String,
 }
 
-#[derive(Default, Debug, Clone, Serialize, Deserialize, JsonSchema, SettingsUi)]
+#[derive(Default, Debug, Clone, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey)]
+#[settings_key(None)]
 pub struct GitHostingProviderSettings {
     /// The list of custom Git hosting providers.
     #[serde(default)]
@@ -86,8 +87,6 @@ pub struct GitHostingProviderSettings {
 }
 
 impl Settings for GitHostingProviderSettings {
-    const KEY: Option<&'static str> = None;
-
     type FileContent = Self;
 
     fn load(sources: settings::SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs
index 64163b0ebc33f908de5c5cd8c97a24418bf4ba43..02a60d8fe33a9da24ddfd50b873b363b3bbcd9c9 100644
--- a/crates/git_ui/src/git_panel.rs
+++ b/crates/git_ui/src/git_panel.rs
@@ -388,9 +388,6 @@ pub(crate) fn commit_message_editor(
     window: &mut Window,
     cx: &mut Context<Editor>,
 ) -> Editor {
-    project.update(cx, |this, cx| {
-        this.mark_buffer_as_non_searchable(commit_message_buffer.read(cx).remote_id(), cx);
-    });
     let buffer = cx.new(|cx| MultiBuffer::singleton(commit_message_buffer, cx));
     let max_lines = if in_panel { MAX_PANEL_EDITOR_LINES } else { 18 };
     let mut commit_editor = Editor::new(
diff --git a/crates/git_ui/src/git_panel_settings.rs b/crates/git_ui/src/git_panel_settings.rs
index 39d6540db52046845521a23c0290be4e6e595492..be207314acd82446566dffd2eb58339974f177ff 100644
--- a/crates/git_ui/src/git_panel_settings.rs
+++ b/crates/git_ui/src/git_panel_settings.rs
@@ -2,7 +2,7 @@ use editor::ShowScrollbar;
 use gpui::Pixels;
 use schemars::JsonSchema;
 use serde_derive::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 use workspace::dock::DockPosition;
 
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
@@ -36,7 +36,8 @@ pub enum StatusStyle {
     LabelColor,
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi, SettingsKey)]
+#[settings_key(key = "git_panel")]
 pub struct GitPanelSettingsContent {
     /// Whether to show the panel button in the status bar.
     ///
@@ -90,8 +91,6 @@ pub struct GitPanelSettings {
 }
 
 impl Settings for GitPanelSettings {
-    const KEY: Option<&'static str> = Some("git_panel");
-
     type FileContent = GitPanelSettingsContent;
 
     fn load(
diff --git a/crates/go_to_line/src/cursor_position.rs b/crates/go_to_line/src/cursor_position.rs
index 5840993ece84b1e8098ee341395e7f77fb791ace..6af8c79fe9cc4ed0be0d7cb466753fa939355eec 100644
--- a/crates/go_to_line/src/cursor_position.rs
+++ b/crates/go_to_line/src/cursor_position.rs
@@ -2,7 +2,7 @@ use editor::{Editor, EditorSettings, MultiBufferSnapshot};
 use gpui::{App, Entity, FocusHandle, Focusable, Subscription, Task, WeakEntity};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 use std::{fmt::Write, num::NonZeroU32, time::Duration};
 use text::{Point, Selection};
 use ui::{
@@ -301,13 +301,12 @@ pub(crate) enum LineIndicatorFormat {
     Long,
 }
 
-#[derive(Clone, Copy, Default, JsonSchema, Deserialize, Serialize, SettingsUi)]
+#[derive(Clone, Copy, Default, JsonSchema, Deserialize, Serialize, SettingsUi, SettingsKey)]
 #[serde(transparent)]
+#[settings_key(key = "line_indicator_format")]
 pub(crate) struct LineIndicatorFormatContent(LineIndicatorFormat);
 
 impl Settings for LineIndicatorFormat {
-    const KEY: Option<&'static str> = Some("line_indicator_format");
-
     type FileContent = LineIndicatorFormatContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> anyhow::Result<Self> {
diff --git a/crates/gpui/examples/data_table.rs b/crates/gpui/examples/data_table.rs
index 5e82b08839de5f3b98ec3267b22a3bb8586fa02c..10e22828a8e8f5c8778cbcb06a087d4bdfac3adc 100644
--- a/crates/gpui/examples/data_table.rs
+++ b/crates/gpui/examples/data_table.rs
@@ -38,58 +38,58 @@ pub struct Quote {
 impl Quote {
     pub fn random() -> Self {
         use rand::Rng;
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         // simulate a base price in a realistic range
-        let prev_close = rng.gen_range(100.0..200.0);
-        let change = rng.gen_range(-5.0..5.0);
+        let prev_close = rng.random_range(100.0..200.0);
+        let change = rng.random_range(-5.0..5.0);
         let last_done = prev_close + change;
-        let open = prev_close + rng.gen_range(-3.0..3.0);
-        let high = (prev_close + rng.gen_range::<f64, _>(0.0..10.0)).max(open);
-        let low = (prev_close - rng.gen_range::<f64, _>(0.0..10.0)).min(open);
-        let timestamp = Duration::from_secs(rng.gen_range(0..86400));
-        let volume = rng.gen_range(1_000_000..100_000_000);
+        let open = prev_close + rng.random_range(-3.0..3.0);
+        let high = (prev_close + rng.random_range::<f64, _>(0.0..10.0)).max(open);
+        let low = (prev_close - rng.random_range::<f64, _>(0.0..10.0)).min(open);
+        let timestamp = Duration::from_secs(rng.random_range(0..86400));
+        let volume = rng.random_range(1_000_000..100_000_000);
         let turnover = last_done * volume as f64;
         let symbol = {
             let mut ticker = String::new();
-            if rng.gen_bool(0.5) {
+            if rng.random_bool(0.5) {
                 ticker.push_str(&format!(
                     "{:03}.{}",
-                    rng.gen_range(100..1000),
-                    rng.gen_range(0..10)
+                    rng.random_range(100..1000),
+                    rng.random_range(0..10)
                 ));
             } else {
                 ticker.push_str(&format!(
                     "{}{}",
-                    rng.gen_range('A'..='Z'),
-                    rng.gen_range('A'..='Z')
+                    rng.random_range('A'..='Z'),
+                    rng.random_range('A'..='Z')
                 ));
             }
-            ticker.push_str(&format!(".{}", rng.gen_range('A'..='Z')));
+            ticker.push_str(&format!(".{}", rng.random_range('A'..='Z')));
             ticker
         };
         let name = format!(
             "{} {} - #{}",
             symbol,
-            rng.gen_range(1..100),
-            rng.gen_range(10000..100000)
+            rng.random_range(1..100),
+            rng.random_range(10000..100000)
         );
-        let ttm = rng.gen_range(0.0..10.0);
-        let market_cap = rng.gen_range(1_000_000.0..10_000_000.0);
-        let float_cap = market_cap + rng.gen_range(1_000.0..10_000.0);
-        let shares = rng.gen_range(100.0..1000.0);
+        let ttm = rng.random_range(0.0..10.0);
+        let market_cap = rng.random_range(1_000_000.0..10_000_000.0);
+        let float_cap = market_cap + rng.random_range(1_000.0..10_000.0);
+        let shares = rng.random_range(100.0..1000.0);
         let pb = market_cap / shares;
         let pe = market_cap / shares;
         let eps = market_cap / shares;
-        let dividend = rng.gen_range(0.0..10.0);
-        let dividend_yield = rng.gen_range(0.0..10.0);
-        let dividend_per_share = rng.gen_range(0.0..10.0);
+        let dividend = rng.random_range(0.0..10.0);
+        let dividend_yield = rng.random_range(0.0..10.0);
+        let dividend_per_share = rng.random_range(0.0..10.0);
         let dividend_date = SharedString::new(format!(
             "{}-{}-{}",
-            rng.gen_range(2000..2023),
-            rng.gen_range(1..12),
-            rng.gen_range(1..28)
+            rng.random_range(2000..2023),
+            rng.random_range(1..12),
+            rng.random_range(1..28)
         ));
-        let dividend_payment = rng.gen_range(0.0..10.0);
+        let dividend_payment = rng.random_range(0.0..10.0);
 
         Self {
             name: name.into(),
diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs
index 69d5c0ee4375443ad42a7b25a64a138406ac95a2..8b0b404d1dffbf8a27de1f29437ce9cc2ba63f0f 100644
--- a/crates/gpui/src/app.rs
+++ b/crates/gpui/src/app.rs
@@ -1358,12 +1358,7 @@ impl App {
         F: FnOnce(AnyView, &mut Window, &mut App) -> T,
     {
         self.update(|cx| {
-            let mut window = cx
-                .windows
-                .get_mut(id)
-                .context("window not found")?
-                .take()
-                .context("window not found")?;
+            let mut window = cx.windows.get_mut(id)?.take()?;
 
             let root_view = window.root.clone().unwrap();
 
@@ -1380,15 +1375,14 @@ impl App {
                     true
                 });
             } else {
-                cx.windows
-                    .get_mut(id)
-                    .context("window not found")?
-                    .replace(window);
+                cx.windows.get_mut(id)?.replace(window);
             }
 
-            Ok(result)
+            Some(result)
         })
+        .context("window not found")
     }
+
     /// Creates an `AsyncApp`, which can be cloned and has a static lifetime
     /// so it can be held across `await` points.
     pub fn to_async(&self) -> AsyncApp {
diff --git a/crates/gpui/src/app/test_context.rs b/crates/gpui/src/app/test_context.rs
index c65c045f6bc16310d3772825147ad570f209fd99..b3d342b09bf1dceb27413d3ec24fbcc0d2f541e9 100644
--- a/crates/gpui/src/app/test_context.rs
+++ b/crates/gpui/src/app/test_context.rs
@@ -144,7 +144,7 @@ impl TestAppContext {
 
     /// Create a single TestAppContext, for non-multi-client tests
     pub fn single() -> Self {
-        let dispatcher = TestDispatcher::new(StdRng::from_entropy());
+        let dispatcher = TestDispatcher::new(StdRng::seed_from_u64(0));
         Self::build(dispatcher, None)
     }
 
diff --git a/crates/gpui/src/arena.rs b/crates/gpui/src/arena.rs
index 0983bd23454c9a3a921ed721ecd32561387f9049..a0d0c23987472de46d5b23129adb5a4ec8ee00cb 100644
--- a/crates/gpui/src/arena.rs
+++ b/crates/gpui/src/arena.rs
@@ -1,8 +1,9 @@
 use std::{
     alloc::{self, handle_alloc_error},
     cell::Cell,
+    num::NonZeroUsize,
     ops::{Deref, DerefMut},
-    ptr,
+    ptr::{self, NonNull},
     rc::Rc,
 };
 
@@ -30,23 +31,23 @@ impl Drop for Chunk {
     fn drop(&mut self) {
         unsafe {
             let chunk_size = self.end.offset_from_unsigned(self.start);
-            // this never fails as it succeeded during allocation
-            let layout = alloc::Layout::from_size_align(chunk_size, 1).unwrap();
+            // SAFETY: This succeeded during allocation.
+            let layout = alloc::Layout::from_size_align_unchecked(chunk_size, 1);
             alloc::dealloc(self.start, layout);
         }
     }
 }
 
 impl Chunk {
-    fn new(chunk_size: usize) -> Self {
+    fn new(chunk_size: NonZeroUsize) -> Self {
         unsafe {
             // this only fails if chunk_size is unreasonably huge
-            let layout = alloc::Layout::from_size_align(chunk_size, 1).unwrap();
+            let layout = alloc::Layout::from_size_align(chunk_size.get(), 1).unwrap();
             let start = alloc::alloc(layout);
             if start.is_null() {
                 handle_alloc_error(layout);
             }
-            let end = start.add(chunk_size);
+            let end = start.add(chunk_size.get());
             Self {
                 start,
                 end,
@@ -55,14 +56,14 @@ impl Chunk {
         }
     }
 
-    fn allocate(&mut self, layout: alloc::Layout) -> Option<*mut u8> {
+    fn allocate(&mut self, layout: alloc::Layout) -> Option<NonNull<u8>> {
         unsafe {
             let aligned = self.offset.add(self.offset.align_offset(layout.align()));
             let next = aligned.add(layout.size());
 
             if next <= self.end {
                 self.offset = next;
-                Some(aligned)
+                NonNull::new(aligned)
             } else {
                 None
             }
@@ -79,7 +80,7 @@ pub struct Arena {
     elements: Vec<ArenaElement>,
     valid: Rc<Cell<bool>>,
     current_chunk_index: usize,
-    chunk_size: usize,
+    chunk_size: NonZeroUsize,
 }
 
 impl Drop for Arena {
@@ -90,7 +91,7 @@ impl Drop for Arena {
 
 impl Arena {
     pub fn new(chunk_size: usize) -> Self {
-        assert!(chunk_size > 0);
+        let chunk_size = NonZeroUsize::try_from(chunk_size).unwrap();
         Self {
             chunks: vec![Chunk::new(chunk_size)],
             elements: Vec::new(),
@@ -101,7 +102,7 @@ impl Arena {
     }
 
     pub fn capacity(&self) -> usize {
-        self.chunks.len() * self.chunk_size
+        self.chunks.len() * self.chunk_size.get()
     }
 
     pub fn clear(&mut self) {
@@ -136,7 +137,7 @@ impl Arena {
             let layout = alloc::Layout::new::<T>();
             let mut current_chunk = &mut self.chunks[self.current_chunk_index];
             let ptr = if let Some(ptr) = current_chunk.allocate(layout) {
-                ptr
+                ptr.as_ptr()
             } else {
                 self.current_chunk_index += 1;
                 if self.current_chunk_index >= self.chunks.len() {
@@ -149,7 +150,7 @@ impl Arena {
                 }
                 current_chunk = &mut self.chunks[self.current_chunk_index];
                 if let Some(ptr) = current_chunk.allocate(layout) {
-                    ptr
+                    ptr.as_ptr()
                 } else {
                     panic!(
                         "Arena chunk_size of {} is too small to allocate {} bytes",
diff --git a/crates/gpui/src/bounds_tree.rs b/crates/gpui/src/bounds_tree.rs
index 03f83b95035489bd86201c4d64c15f5a12ed50ea..a96bfe55b9ff431a96da7bf42692288264eb184c 100644
--- a/crates/gpui/src/bounds_tree.rs
+++ b/crates/gpui/src/bounds_tree.rs
@@ -309,12 +309,12 @@ mod tests {
             let mut expected_quads: Vec<(Bounds<f32>, u32)> = Vec::new();
 
             // Insert a random number of random AABBs into the tree.
-            let num_bounds = rng.gen_range(1..=max_bounds);
+            let num_bounds = rng.random_range(1..=max_bounds);
             for _ in 0..num_bounds {
-                let min_x: f32 = rng.gen_range(-100.0..100.0);
-                let min_y: f32 = rng.gen_range(-100.0..100.0);
-                let width: f32 = rng.gen_range(0.0..50.0);
-                let height: f32 = rng.gen_range(0.0..50.0);
+                let min_x: f32 = rng.random_range(-100.0..100.0);
+                let min_y: f32 = rng.random_range(-100.0..100.0);
+                let width: f32 = rng.random_range(0.0..50.0);
+                let height: f32 = rng.random_range(0.0..50.0);
                 let bounds = Bounds {
                     origin: Point { x: min_x, y: min_y },
                     size: Size { width, height },
diff --git a/crates/gpui/src/platform.rs b/crates/gpui/src/platform.rs
index d3425c8835bb474ffbed6bc79371340d569d1bfb..444b60ac154424c423c3cd6a827b22cd7024694f 100644
--- a/crates/gpui/src/platform.rs
+++ b/crates/gpui/src/platform.rs
@@ -39,9 +39,9 @@ use crate::{
     Action, AnyWindowHandle, App, AsyncWindowContext, BackgroundExecutor, Bounds,
     DEFAULT_WINDOW_SIZE, DevicePixels, DispatchEventResult, Font, FontId, FontMetrics, FontRun,
     ForegroundExecutor, GlyphId, GpuSpecs, ImageSource, Keymap, LineLayout, Pixels, PlatformInput,
-    Point, RenderGlyphParams, RenderImage, RenderImageParams, RenderSvgParams, ScaledPixels, Scene,
-    ShapedGlyph, ShapedRun, SharedString, Size, SvgRenderer, SvgSize, SystemWindowTab, Task,
-    TaskLabel, Window, WindowControlArea, hash, point, px, size,
+    Point, RenderGlyphParams, RenderImage, RenderImageParams, RenderSvgParams, Scene, ShapedGlyph,
+    ShapedRun, SharedString, Size, SvgRenderer, SvgSize, SystemWindowTab, Task, TaskLabel, Window,
+    WindowControlArea, hash, point, px, size,
 };
 use anyhow::Result;
 use async_task::Runnable;
@@ -548,7 +548,7 @@ pub(crate) trait PlatformWindow: HasWindowHandle + HasDisplayHandle {
     fn set_client_inset(&self, _inset: Pixels) {}
     fn gpu_specs(&self) -> Option<GpuSpecs>;
 
-    fn update_ime_position(&self, _bounds: Bounds<ScaledPixels>);
+    fn update_ime_position(&self, _bounds: Bounds<Pixels>);
 
     #[cfg(any(test, feature = "test-support"))]
     fn as_test(&mut self) -> Option<&mut TestWindow> {
diff --git a/crates/gpui/src/platform/blade/blade_renderer.rs b/crates/gpui/src/platform/blade/blade_renderer.rs
index cc1df7748ba6b7947ab53a86baa8ab31644ac05d..1f60920bcc928c97c1f2b2c06e22ed235217c87e 100644
--- a/crates/gpui/src/platform/blade/blade_renderer.rs
+++ b/crates/gpui/src/platform/blade/blade_renderer.rs
@@ -371,7 +371,7 @@ impl BladeRenderer {
             .or_else(|| {
                 [4, 2, 1]
                     .into_iter()
-                    .find(|count| context.gpu.supports_texture_sample_count(*count))
+                    .find(|&n| (context.gpu.capabilities().sample_count_mask & n) != 0)
             })
             .unwrap_or(1);
         let pipelines = BladePipelines::new(&context.gpu, surface.info(), path_sample_count);
diff --git a/crates/gpui/src/platform/linux/wayland/client.rs b/crates/gpui/src/platform/linux/wayland/client.rs
index 189cfa19545f052cf8ebc75b89c1f955d3396859..8596bddc8dd821426982d618f661d6da621096bb 100644
--- a/crates/gpui/src/platform/linux/wayland/client.rs
+++ b/crates/gpui/src/platform/linux/wayland/client.rs
@@ -75,8 +75,8 @@ use crate::{
     FileDropEvent, ForegroundExecutor, KeyDownEvent, KeyUpEvent, Keystroke, LinuxCommon,
     LinuxKeyboardLayout, Modifiers, ModifiersChangedEvent, MouseButton, MouseDownEvent,
     MouseExitEvent, MouseMoveEvent, MouseUpEvent, NavigationDirection, Pixels, PlatformDisplay,
-    PlatformInput, PlatformKeyboardLayout, Point, SCROLL_LINES, ScaledPixels, ScrollDelta,
-    ScrollWheelEvent, Size, TouchPhase, WindowParams, point, px, size,
+    PlatformInput, PlatformKeyboardLayout, Point, SCROLL_LINES, ScrollDelta, ScrollWheelEvent,
+    Size, TouchPhase, WindowParams, point, px, size,
 };
 use crate::{
     SharedString,
@@ -323,7 +323,7 @@ impl WaylandClientStatePtr {
         }
     }
 
-    pub fn update_ime_position(&self, bounds: Bounds<ScaledPixels>) {
+    pub fn update_ime_position(&self, bounds: Bounds<Pixels>) {
         let client = self.get_client();
         let mut state = client.borrow_mut();
         if state.composing || state.text_input.is_none() || state.pre_edit_text.is_some() {
diff --git a/crates/gpui/src/platform/linux/wayland/window.rs b/crates/gpui/src/platform/linux/wayland/window.rs
index 7570c58c09e8d5c63091174fa51bc30c54c005e1..76dd89c940c615d726af1cf5922be226d91dfd41 100644
--- a/crates/gpui/src/platform/linux/wayland/window.rs
+++ b/crates/gpui/src/platform/linux/wayland/window.rs
@@ -25,9 +25,8 @@ use crate::scene::Scene;
 use crate::{
     AnyWindowHandle, Bounds, Decorations, Globals, GpuSpecs, Modifiers, Output, Pixels,
     PlatformDisplay, PlatformInput, Point, PromptButton, PromptLevel, RequestFrameOptions,
-    ResizeEdge, ScaledPixels, Size, Tiling, WaylandClientStatePtr, WindowAppearance,
-    WindowBackgroundAppearance, WindowBounds, WindowControlArea, WindowControls, WindowDecorations,
-    WindowParams, px, size,
+    ResizeEdge, Size, Tiling, WaylandClientStatePtr, WindowAppearance, WindowBackgroundAppearance,
+    WindowBounds, WindowControlArea, WindowControls, WindowDecorations, WindowParams, px, size,
 };
 use crate::{
     Capslock,
@@ -1078,7 +1077,7 @@ impl PlatformWindow for WaylandWindow {
         }
     }
 
-    fn update_ime_position(&self, bounds: Bounds<ScaledPixels>) {
+    fn update_ime_position(&self, bounds: Bounds<Pixels>) {
         let state = self.borrow();
         state.client.update_ime_position(bounds);
     }
diff --git a/crates/gpui/src/platform/linux/x11/client.rs b/crates/gpui/src/platform/linux/x11/client.rs
index 9a43bd64706ec21905b18b8837af2ddc785cba87..42c59701d3ee644b99bc8bb58002b429265c1a45 100644
--- a/crates/gpui/src/platform/linux/x11/client.rs
+++ b/crates/gpui/src/platform/linux/x11/client.rs
@@ -62,8 +62,7 @@ use crate::{
     AnyWindowHandle, Bounds, ClipboardItem, CursorStyle, DisplayId, FileDropEvent, Keystroke,
     LinuxKeyboardLayout, Modifiers, ModifiersChangedEvent, MouseButton, Pixels, Platform,
     PlatformDisplay, PlatformInput, PlatformKeyboardLayout, Point, RequestFrameOptions,
-    ScaledPixels, ScrollDelta, Size, TouchPhase, WindowParams, X11Window,
-    modifiers_from_xinput_info, point, px,
+    ScrollDelta, Size, TouchPhase, WindowParams, X11Window, modifiers_from_xinput_info, point, px,
 };
 
 /// Value for DeviceId parameters which selects all devices.
@@ -252,7 +251,7 @@ impl X11ClientStatePtr {
         }
     }
 
-    pub fn update_ime_position(&self, bounds: Bounds<ScaledPixels>) {
+    pub fn update_ime_position(&self, bounds: Bounds<Pixels>) {
         let Some(client) = self.get_client() else {
             return;
         };
@@ -270,6 +269,7 @@ impl X11ClientStatePtr {
             state.ximc = Some(ximc);
             return;
         };
+        let scaled_bounds = bounds.scale(state.scale_factor);
         let ic_attributes = ximc
             .build_ic_attributes()
             .push(
@@ -282,8 +282,8 @@ impl X11ClientStatePtr {
                 b.push(
                     xim::AttributeName::SpotLocation,
                     xim::Point {
-                        x: u32::from(bounds.origin.x + bounds.size.width) as i16,
-                        y: u32::from(bounds.origin.y + bounds.size.height) as i16,
+                        x: u32::from(scaled_bounds.origin.x + scaled_bounds.size.width) as i16,
+                        y: u32::from(scaled_bounds.origin.y + scaled_bounds.size.height) as i16,
                     },
                 );
             })
@@ -703,14 +703,14 @@ impl X11Client {
                 state.xim_handler = Some(xim_handler);
                 return;
             };
-            if let Some(area) = window.get_ime_area() {
+            if let Some(scaled_area) = window.get_ime_area() {
                 ic_attributes =
                     ic_attributes.nested_list(xim::AttributeName::PreeditAttributes, |b| {
                         b.push(
                             xim::AttributeName::SpotLocation,
                             xim::Point {
-                                x: u32::from(area.origin.x + area.size.width) as i16,
-                                y: u32::from(area.origin.y + area.size.height) as i16,
+                                x: u32::from(scaled_area.origin.x + scaled_area.size.width) as i16,
+                                y: u32::from(scaled_area.origin.y + scaled_area.size.height) as i16,
                             },
                         );
                     });
@@ -1351,7 +1351,7 @@ impl X11Client {
         drop(state);
         window.handle_ime_preedit(text);
 
-        if let Some(area) = window.get_ime_area() {
+        if let Some(scaled_area) = window.get_ime_area() {
             let ic_attributes = ximc
                 .build_ic_attributes()
                 .push(
@@ -1364,8 +1364,8 @@ impl X11Client {
                     b.push(
                         xim::AttributeName::SpotLocation,
                         xim::Point {
-                            x: u32::from(area.origin.x + area.size.width) as i16,
-                            y: u32::from(area.origin.y + area.size.height) as i16,
+                            x: u32::from(scaled_area.origin.x + scaled_area.size.width) as i16,
+                            y: u32::from(scaled_area.origin.y + scaled_area.size.height) as i16,
                         },
                     );
                 })
diff --git a/crates/gpui/src/platform/linux/x11/window.rs b/crates/gpui/src/platform/linux/x11/window.rs
index 6af943b31761dc26b2cde4090cad4ce6574dd5c9..79a43837252f7dc702b43176d2f06172a3acec18 100644
--- a/crates/gpui/src/platform/linux/x11/window.rs
+++ b/crates/gpui/src/platform/linux/x11/window.rs
@@ -1019,8 +1019,9 @@ impl X11WindowStatePtr {
         }
     }
 
-    pub fn get_ime_area(&self) -> Option<Bounds<Pixels>> {
+    pub fn get_ime_area(&self) -> Option<Bounds<ScaledPixels>> {
         let mut state = self.state.borrow_mut();
+        let scale_factor = state.scale_factor;
         let mut bounds: Option<Bounds<Pixels>> = None;
         if let Some(mut input_handler) = state.input_handler.take() {
             drop(state);
@@ -1030,7 +1031,7 @@ impl X11WindowStatePtr {
             let mut state = self.state.borrow_mut();
             state.input_handler = Some(input_handler);
         };
-        bounds
+        bounds.map(|b| b.scale(scale_factor))
     }
 
     pub fn set_bounds(&self, bounds: Bounds<i32>) -> anyhow::Result<()> {
@@ -1618,7 +1619,7 @@ impl PlatformWindow for X11Window {
         }
     }
 
-    fn update_ime_position(&self, bounds: Bounds<ScaledPixels>) {
+    fn update_ime_position(&self, bounds: Bounds<Pixels>) {
         let mut state = self.0.state.borrow_mut();
         let client = state.client.clone();
         drop(state);
diff --git a/crates/gpui/src/platform/mac/text_system.rs b/crates/gpui/src/platform/mac/text_system.rs
index 72a0f2e565d9937e3aaf4082b663c3e2ae6ac91d..9144b2a23a40bd527e1441cf71adcc2562c33f3c 100644
--- a/crates/gpui/src/platform/mac/text_system.rs
+++ b/crates/gpui/src/platform/mac/text_system.rs
@@ -16,7 +16,7 @@ use core_foundation::{
 use core_graphics::{
     base::{CGGlyph, kCGImageAlphaPremultipliedLast},
     color_space::CGColorSpace,
-    context::CGContext,
+    context::{CGContext, CGTextDrawingMode},
     display::CGPoint,
 };
 use core_text::{
@@ -396,6 +396,12 @@ impl MacTextSystemState {
             let subpixel_shift = params
                 .subpixel_variant
                 .map(|v| v as f32 / SUBPIXEL_VARIANTS as f32);
+            cx.set_allows_font_smoothing(true);
+            cx.set_should_smooth_fonts(true);
+            cx.set_text_drawing_mode(CGTextDrawingMode::CGTextFill);
+            cx.set_gray_fill_color(0.0, 1.0);
+            cx.set_allows_antialiasing(true);
+            cx.set_should_antialias(true);
             cx.set_allows_font_subpixel_positioning(true);
             cx.set_should_subpixel_position_fonts(true);
             cx.set_allows_font_subpixel_quantization(false);
diff --git a/crates/gpui/src/platform/mac/window.rs b/crates/gpui/src/platform/mac/window.rs
index 686cfb314e58c4e10e916a07931fb5f4248ea54e..1230a704062ba835bceb5db5d2ecf05b688e34df 100644
--- a/crates/gpui/src/platform/mac/window.rs
+++ b/crates/gpui/src/platform/mac/window.rs
@@ -4,10 +4,9 @@ use crate::{
     ForegroundExecutor, KeyDownEvent, Keystroke, Modifiers, ModifiersChangedEvent, MouseButton,
     MouseDownEvent, MouseMoveEvent, MouseUpEvent, Pixels, PlatformAtlas, PlatformDisplay,
     PlatformInput, PlatformWindow, Point, PromptButton, PromptLevel, RequestFrameOptions,
-    ScaledPixels, SharedString, Size, SystemWindowTab, Timer, WindowAppearance,
-    WindowBackgroundAppearance, WindowBounds, WindowControlArea, WindowKind, WindowParams,
-    dispatch_get_main_queue, dispatch_sys::dispatch_async_f, platform::PlatformInputHandler, point,
-    px, size,
+    SharedString, Size, SystemWindowTab, Timer, WindowAppearance, WindowBackgroundAppearance,
+    WindowBounds, WindowControlArea, WindowKind, WindowParams, dispatch_get_main_queue,
+    dispatch_sys::dispatch_async_f, platform::PlatformInputHandler, point, px, size,
 };
 use block::ConcreteBlock;
 use cocoa::{
@@ -1480,7 +1479,7 @@ impl PlatformWindow for MacWindow {
         None
     }
 
-    fn update_ime_position(&self, _bounds: Bounds<ScaledPixels>) {
+    fn update_ime_position(&self, _bounds: Bounds<Pixels>) {
         let executor = self.0.lock().executor.clone();
         executor
             .spawn(async move {
diff --git a/crates/gpui/src/platform/test/dispatcher.rs b/crates/gpui/src/platform/test/dispatcher.rs
index 4ce62c4bdcae60d517dd88501cb89af8fee2c9bc..e19710effda9299c6eb72e8c4acc2f615ac077ee 100644
--- a/crates/gpui/src/platform/test/dispatcher.rs
+++ b/crates/gpui/src/platform/test/dispatcher.rs
@@ -118,7 +118,7 @@ impl TestDispatcher {
         }
 
         YieldNow {
-            count: self.state.lock().random.gen_range(0..10),
+            count: self.state.lock().random.random_range(0..10),
         }
     }
 
@@ -151,11 +151,11 @@ impl TestDispatcher {
             if deprioritized_background_len == 0 {
                 return false;
             }
-            let ix = state.random.gen_range(0..deprioritized_background_len);
+            let ix = state.random.random_range(0..deprioritized_background_len);
             main_thread = false;
             runnable = state.deprioritized_background.swap_remove(ix);
         } else {
-            main_thread = state.random.gen_ratio(
+            main_thread = state.random.random_ratio(
                 foreground_len as u32,
                 (foreground_len + background_len) as u32,
             );
@@ -170,7 +170,7 @@ impl TestDispatcher {
                     .pop_front()
                     .unwrap();
             } else {
-                let ix = state.random.gen_range(0..background_len);
+                let ix = state.random.random_range(0..background_len);
                 runnable = state.background.swap_remove(ix);
             };
         };
@@ -241,7 +241,7 @@ impl TestDispatcher {
     pub fn gen_block_on_ticks(&self) -> usize {
         let mut lock = self.state.lock();
         let block_on_ticks = lock.block_on_ticks.clone();
-        lock.random.gen_range(block_on_ticks)
+        lock.random.random_range(block_on_ticks)
     }
 }
 
diff --git a/crates/gpui/src/platform/test/window.rs b/crates/gpui/src/platform/test/window.rs
index e15bd7aeecec5932eb6386bd47d168eda906dd63..9e87f4504ddd61e34b645ea69ea394c4940f9d55 100644
--- a/crates/gpui/src/platform/test/window.rs
+++ b/crates/gpui/src/platform/test/window.rs
@@ -1,8 +1,8 @@
 use crate::{
     AnyWindowHandle, AtlasKey, AtlasTextureId, AtlasTile, Bounds, DispatchEventResult, GpuSpecs,
     Pixels, PlatformAtlas, PlatformDisplay, PlatformInput, PlatformInputHandler, PlatformWindow,
-    Point, PromptButton, RequestFrameOptions, ScaledPixels, Size, TestPlatform, TileId,
-    WindowAppearance, WindowBackgroundAppearance, WindowBounds, WindowControlArea, WindowParams,
+    Point, PromptButton, RequestFrameOptions, Size, TestPlatform, TileId, WindowAppearance,
+    WindowBackgroundAppearance, WindowBounds, WindowControlArea, WindowParams,
 };
 use collections::HashMap;
 use parking_lot::Mutex;
@@ -289,7 +289,7 @@ impl PlatformWindow for TestWindow {
         unimplemented!()
     }
 
-    fn update_ime_position(&self, _bounds: Bounds<ScaledPixels>) {}
+    fn update_ime_position(&self, _bounds: Bounds<Pixels>) {}
 
     fn gpu_specs(&self) -> Option<GpuSpecs> {
         None
diff --git a/crates/gpui/src/platform/windows/directx_devices.rs b/crates/gpui/src/platform/windows/directx_devices.rs
index 005737ca2070ab8a30656493b548c6f3c6e9a3dc..4fa4db827492faffaa0d8912b1f37b52f8cfc88f 100644
--- a/crates/gpui/src/platform/windows/directx_devices.rs
+++ b/crates/gpui/src/platform/windows/directx_devices.rs
@@ -8,8 +8,9 @@ use windows::Win32::{
             D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_11_1,
         },
         Direct3D11::{
-            D3D11_CREATE_DEVICE_BGRA_SUPPORT, D3D11_CREATE_DEVICE_DEBUG, D3D11_SDK_VERSION,
-            D3D11CreateDevice, ID3D11Device, ID3D11DeviceContext,
+            D3D11_CREATE_DEVICE_BGRA_SUPPORT, D3D11_CREATE_DEVICE_DEBUG,
+            D3D11_FEATURE_D3D10_X_HARDWARE_OPTIONS, D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS,
+            D3D11_SDK_VERSION, D3D11CreateDevice, ID3D11Device, ID3D11DeviceContext,
         },
         Dxgi::{
             CreateDXGIFactory2, DXGI_CREATE_FACTORY_DEBUG, DXGI_CREATE_FACTORY_FLAGS,
@@ -54,12 +55,10 @@ impl DirectXDevices {
         let adapter =
             get_adapter(&dxgi_factory, debug_layer_available).context("Getting DXGI adapter")?;
         let (device, device_context) = {
-            let mut device: Option<ID3D11Device> = None;
             let mut context: Option<ID3D11DeviceContext> = None;
             let mut feature_level = D3D_FEATURE_LEVEL::default();
-            get_device(
+            let device = get_device(
                 &adapter,
-                Some(&mut device),
                 Some(&mut context),
                 Some(&mut feature_level),
                 debug_layer_available,
@@ -77,7 +76,7 @@ impl DirectXDevices {
                 }
                 _ => unreachable!(),
             }
-            (device.unwrap(), context.unwrap())
+            (device, context.unwrap())
         };
 
         Ok(Self {
@@ -134,7 +133,7 @@ fn get_adapter(dxgi_factory: &IDXGIFactory6, debug_layer_available: bool) -> Res
         }
         // Check to see whether the adapter supports Direct3D 11, but don't
         // create the actual device yet.
-        if get_device(&adapter, None, None, None, debug_layer_available)
+        if get_device(&adapter, None, None, debug_layer_available)
             .log_err()
             .is_some()
         {
@@ -148,11 +147,11 @@ fn get_adapter(dxgi_factory: &IDXGIFactory6, debug_layer_available: bool) -> Res
 #[inline]
 fn get_device(
     adapter: &IDXGIAdapter1,
-    device: Option<*mut Option<ID3D11Device>>,
     context: Option<*mut Option<ID3D11DeviceContext>>,
     feature_level: Option<*mut D3D_FEATURE_LEVEL>,
     debug_layer_available: bool,
-) -> Result<()> {
+) -> Result<ID3D11Device> {
+    let mut device: Option<ID3D11Device> = None;
     let device_flags = if debug_layer_available {
         D3D11_CREATE_DEVICE_BGRA_SUPPORT | D3D11_CREATE_DEVICE_DEBUG
     } else {
@@ -171,10 +170,30 @@ fn get_device(
                 D3D_FEATURE_LEVEL_10_1,
             ]),
             D3D11_SDK_VERSION,
-            device,
+            Some(&mut device),
             feature_level,
             context,
         )?;
     }
-    Ok(())
+    let device = device.unwrap();
+    let mut data = D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS::default();
+    unsafe {
+        device
+            .CheckFeatureSupport(
+                D3D11_FEATURE_D3D10_X_HARDWARE_OPTIONS,
+                &mut data as *mut _ as _,
+                std::mem::size_of::<D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS>() as u32,
+            )
+            .context("Checking GPU device feature support")?;
+    }
+    if data
+        .ComputeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x
+        .as_bool()
+    {
+        Ok(device)
+    } else {
+        Err(anyhow::anyhow!(
+            "Required feature StructuredBuffer is not supported by GPU/driver"
+        ))
+    }
 }
diff --git a/crates/gpui/src/platform/windows/platform.rs b/crates/gpui/src/platform/windows/platform.rs
index 96db8077c4b7b139bf2c724a3502a6e4bd194f9f..4d0e6ea56f7d90f303f6634de1239a6a4542429a 100644
--- a/crates/gpui/src/platform/windows/platform.rs
+++ b/crates/gpui/src/platform/windows/platform.rs
@@ -94,7 +94,11 @@ impl WindowsPlatform {
         }
         let directx_devices = DirectXDevices::new().context("Creating DirectX devices")?;
         let (main_sender, main_receiver) = flume::unbounded::<Runnable>();
-        let validation_number = rand::random::<usize>();
+        let validation_number = if usize::BITS == 64 {
+            rand::random::<u64>() as usize
+        } else {
+            rand::random::<u32>() as usize
+        };
         let raw_window_handles = Arc::new(RwLock::new(SmallVec::new()));
         let text_system = Arc::new(
             DirectWriteTextSystem::new(&directx_devices)
diff --git a/crates/gpui/src/platform/windows/window.rs b/crates/gpui/src/platform/windows/window.rs
index 9d001da822315c76aa9a16b010a38407c5730386..aa907c8d734973fc4fc795b6d8ebf7654d1b40de 100644
--- a/crates/gpui/src/platform/windows/window.rs
+++ b/crates/gpui/src/platform/windows/window.rs
@@ -839,7 +839,7 @@ impl PlatformWindow for WindowsWindow {
         self.0.state.borrow().renderer.gpu_specs().log_err()
     }
 
-    fn update_ime_position(&self, _bounds: Bounds<ScaledPixels>) {
+    fn update_ime_position(&self, _bounds: Bounds<Pixels>) {
         // There is no such thing on Windows.
     }
 }
diff --git a/crates/gpui/src/util.rs b/crates/gpui/src/util.rs
index 3d7fa06e6ca013ae38b1c63d1bfd624d46cdf4f1..3704784a954f14b8317202e227ffb1b17092d70d 100644
--- a/crates/gpui/src/util.rs
+++ b/crates/gpui/src/util.rs
@@ -99,9 +99,9 @@ impl<T: Future> Future for WithTimeout<T> {
     fn poll(self: Pin<&mut Self>, cx: &mut task::Context) -> task::Poll<Self::Output> {
         // SAFETY: the fields of Timeout are private and we never move the future ourselves
         // And its already pinned since we are being polled (all futures need to be pinned to be polled)
-        let this = unsafe { self.get_unchecked_mut() };
-        let future = unsafe { Pin::new_unchecked(&mut this.future) };
-        let timer = unsafe { Pin::new_unchecked(&mut this.timer) };
+        let this = unsafe { &raw mut *self.get_unchecked_mut() };
+        let future = unsafe { Pin::new_unchecked(&mut (*this).future) };
+        let timer = unsafe { Pin::new_unchecked(&mut (*this).timer) };
 
         if let task::Poll::Ready(output) = future.poll(cx) {
             task::Poll::Ready(Ok(output))
diff --git a/crates/gpui/src/window.rs b/crates/gpui/src/window.rs
index 0ec73c4b0040e6c65cd8819ecf5d20a9ec1900d0..61d15cb3ed41751ce08c00599bbe28fc0c0cadb2 100644
--- a/crates/gpui/src/window.rs
+++ b/crates/gpui/src/window.rs
@@ -4096,9 +4096,7 @@ impl Window {
         self.on_next_frame(|window, cx| {
             if let Some(mut input_handler) = window.platform_window.take_input_handler() {
                 if let Some(bounds) = input_handler.selected_bounds(window, cx) {
-                    window
-                        .platform_window
-                        .update_ime_position(bounds.scale(window.scale_factor()));
+                    window.platform_window.update_ime_position(bounds);
                 }
                 window.platform_window.set_input_handler(input_handler);
             }
diff --git a/crates/image_viewer/src/image_viewer_settings.rs b/crates/image_viewer/src/image_viewer_settings.rs
index 4949b266b4e03c7089d4bc25e2a223a0ce64a081..510de69b522fbb07cb8eedba43edfe3a95e4a591 100644
--- a/crates/image_viewer/src/image_viewer_settings.rs
+++ b/crates/image_viewer/src/image_viewer_settings.rs
@@ -1,10 +1,11 @@
 use gpui::App;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 
 /// The settings for the image viewer.
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, Default, SettingsUi)]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, Default, SettingsUi, SettingsKey)]
+#[settings_key(key = "image_viewer")]
 pub struct ImageViewerSettings {
     /// The unit to use for displaying image file sizes.
     ///
@@ -24,8 +25,6 @@ pub enum ImageFileSizeUnit {
 }
 
 impl Settings for ImageViewerSettings {
-    const KEY: Option<&'static str> = Some("image_viewer");
-
     type FileContent = Self;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> anyhow::Result<Self> {
diff --git a/crates/journal/src/journal.rs b/crates/journal/src/journal.rs
index ffa24571c88a0f0e06252565261b1a6d285d098c..5cdfa6c1df034deaf06e1c99ea99415757b84c29 100644
--- a/crates/journal/src/journal.rs
+++ b/crates/journal/src/journal.rs
@@ -5,7 +5,7 @@ use editor::{Editor, SelectionEffects};
 use gpui::{App, AppContext as _, Context, Window, actions};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 use std::{
     fs::OpenOptions,
     path::{Path, PathBuf},
@@ -22,7 +22,8 @@ actions!(
 );
 
 /// Settings specific to journaling
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, SettingsUi)]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey)]
+#[settings_key(key = "journal")]
 pub struct JournalSettings {
     /// The path of the directory where journal entries are stored.
     ///
@@ -52,8 +53,6 @@ pub enum HourFormat {
 }
 
 impl settings::Settings for JournalSettings {
-    const KEY: Option<&'static str> = Some("journal");
-
     type FileContent = Self;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
diff --git a/crates/keymap_editor/src/keymap_editor.rs b/crates/keymap_editor/src/keymap_editor.rs
index a8e356276b31e1d6daa79fdf85f6ff3566f9749d..7e0a96d47a52b7051793017a2d5f68d64bfdcd65 100644
--- a/crates/keymap_editor/src/keymap_editor.rs
+++ b/crates/keymap_editor/src/keymap_editor.rs
@@ -1576,33 +1576,6 @@ impl Render for KeymapEditor {
                     .child(
                         h_flex()
                             .gap_2()
-                            .child(
-                                right_click_menu("open-keymap-menu")
-                                    .menu(|window, cx| {
-                                        ContextMenu::build(window, cx, |menu, _, _| {
-                                            menu.header("Open Keymap JSON")
-                                                .action("User", zed_actions::OpenKeymap.boxed_clone())
-                                                .action("Zed Default", zed_actions::OpenDefaultKeymap.boxed_clone())
-                                                .action("Vim Default", vim::OpenDefaultKeymap.boxed_clone())
-                                        })
-                                    })
-                                    .anchor(gpui::Corner::TopLeft)
-                                    .trigger(|open, _, _|
-                                        IconButton::new(
-                                            "OpenKeymapJsonButton",
-                                            IconName::Json
-                                        )
-                                        .shape(ui::IconButtonShape::Square)
-                                        .when(!open, |this|
-                                            this.tooltip(move |window, cx| {
-                                                Tooltip::with_meta("Open Keymap JSON", Some(&zed_actions::OpenKeymap),"Right click to view more options", window, cx)
-                                            })
-                                        )
-                                        .on_click(|_, window, cx| {
-                                            window.dispatch_action(zed_actions::OpenKeymap.boxed_clone(), cx);
-                                        })
-                                    )
-                            )
                             .child(
                                 div()
                                     .key_context({
@@ -1617,73 +1590,139 @@ impl Render for KeymapEditor {
                                     .py_1()
                                     .border_1()
                                     .border_color(theme.colors().border)
-                                    .rounded_lg()
+                                    .rounded_md()
                                     .child(self.filter_editor.clone()),
                             )
                             .child(
-                                IconButton::new(
-                                    "KeymapEditorToggleFiltersIcon",
-                                    IconName::Keyboard,
-                                )
-                                .shape(ui::IconButtonShape::Square)
-                                .tooltip({
-                                    let focus_handle = focus_handle.clone();
-
-                                    move |window, cx| {
-                                        Tooltip::for_action_in(
-                                            "Search by Keystroke",
-                                            &ToggleKeystrokeSearch,
-                                            &focus_handle.clone(),
-                                            window,
-                                            cx,
+                                h_flex()
+                                    .gap_1()
+                                    .min_w_64()
+                                    .child(
+                                        IconButton::new(
+                                            "KeymapEditorToggleFiltersIcon",
+                                            IconName::Keyboard,
                                         )
-                                    }
-                                })
-                                .toggle_state(matches!(
-                                    self.search_mode,
-                                    SearchMode::KeyStroke { .. }
-                                ))
-                                .on_click(|_, window, cx| {
-                                    window.dispatch_action(ToggleKeystrokeSearch.boxed_clone(), cx);
-                                }),
-                            )
-                            .child(
-                                IconButton::new("KeymapEditorConflictIcon", IconName::Warning)
-                                    .shape(ui::IconButtonShape::Square)
-                                    .when(
-                                        self.keybinding_conflict_state.any_user_binding_conflicts(),
-                                        |this| {
-                                            this.indicator(Indicator::dot().color(Color::Warning))
-                                        },
+                                        .icon_size(IconSize::Small)
+                                        .tooltip({
+                                            let focus_handle = focus_handle.clone();
+
+                                            move |window, cx| {
+                                                Tooltip::for_action_in(
+                                                    "Search by Keystroke",
+                                                    &ToggleKeystrokeSearch,
+                                                    &focus_handle.clone(),
+                                                    window,
+                                                    cx,
+                                                )
+                                            }
+                                        })
+                                        .toggle_state(matches!(
+                                            self.search_mode,
+                                            SearchMode::KeyStroke { .. }
+                                        ))
+                                        .on_click(|_, window, cx| {
+                                            window.dispatch_action(
+                                                ToggleKeystrokeSearch.boxed_clone(),
+                                                cx,
+                                            );
+                                        }),
                                     )
-                                    .tooltip({
-                                        let filter_state = self.filter_state;
-                                        let focus_handle = focus_handle.clone();
-
-                                        move |window, cx| {
-                                            Tooltip::for_action_in(
-                                                match filter_state {
-                                                    FilterState::All => "Show Conflicts",
-                                                    FilterState::Conflicts => "Hide Conflicts",
+                                    .child(
+                                        IconButton::new("KeymapEditorConflictIcon", IconName::Warning)
+                                            .icon_size(IconSize::Small)
+                                            .when(
+                                                self.keybinding_conflict_state
+                                                    .any_user_binding_conflicts(),
+                                                |this| {
+                                                    this.indicator(
+                                                        Indicator::dot().color(Color::Warning),
+                                                    )
                                                 },
-                                                &ToggleConflictFilter,
-                                                &focus_handle.clone(),
-                                                window,
-                                                cx,
                                             )
-                                        }
-                                    })
-                                    .selected_icon_color(Color::Warning)
-                                    .toggle_state(matches!(
-                                        self.filter_state,
-                                        FilterState::Conflicts
-                                    ))
-                                    .on_click(|_, window, cx| {
-                                        window.dispatch_action(
-                                            ToggleConflictFilter.boxed_clone(),
-                                            cx,
-                                        );
-                                    }),
+                                            .tooltip({
+                                                let filter_state = self.filter_state;
+                                                let focus_handle = focus_handle.clone();
+
+                                                move |window, cx| {
+                                                    Tooltip::for_action_in(
+                                                        match filter_state {
+                                                            FilterState::All => "Show Conflicts",
+                                                            FilterState::Conflicts => {
+                                                                "Hide Conflicts"
+                                                            }
+                                                        },
+                                                        &ToggleConflictFilter,
+                                                        &focus_handle.clone(),
+                                                        window,
+                                                        cx,
+                                                    )
+                                                }
+                                            })
+                                            .selected_icon_color(Color::Warning)
+                                            .toggle_state(matches!(
+                                                self.filter_state,
+                                                FilterState::Conflicts
+                                            ))
+                                            .on_click(|_, window, cx| {
+                                                window.dispatch_action(
+                                                    ToggleConflictFilter.boxed_clone(),
+                                                    cx,
+                                                );
+                                            }),
+                                    )
+                                    .child(
+                                        div()
+                                            .ml_1()
+                                            .pl_2()
+                                            .border_l_1()
+                                            .border_color(cx.theme().colors().border_variant)
+                                            .child(
+                                                right_click_menu("open-keymap-menu")
+                                                    .menu(|window, cx| {
+                                                        ContextMenu::build(window, cx, |menu, _, _| {
+                                                            menu.header("Open Keymap JSON")
+                                                                .action(
+                                                                    "User",
+                                                                    zed_actions::OpenKeymap.boxed_clone(),
+                                                                )
+                                                                .action(
+                                                                    "Zed Default",
+                                                                    zed_actions::OpenDefaultKeymap
+                                                                        .boxed_clone(),
+                                                                )
+                                                                .action(
+                                                                    "Vim Default",
+                                                                    vim::OpenDefaultKeymap.boxed_clone(),
+                                                                )
+                                                        })
+                                                    })
+                                                    .anchor(gpui::Corner::TopLeft)
+                                                    .trigger(|open, _, _| {
+                                                        IconButton::new(
+                                                            "OpenKeymapJsonButton",
+                                                            IconName::Json,
+                                                        )
+                                                        .icon_size(IconSize::Small)
+                                                        .when(!open, |this| {
+                                                            this.tooltip(move |window, cx| {
+                                                                Tooltip::with_meta(
+                                                                    "Open keymap.json",
+                                                                    Some(&zed_actions::OpenKeymap),
+                                                                    "Right click to view more options",
+                                                                    window,
+                                                                    cx,
+                                                                )
+                                                            })
+                                                        })
+                                                        .on_click(|_, window, cx| {
+                                                            window.dispatch_action(
+                                                                zed_actions::OpenKeymap.boxed_clone(),
+                                                                cx,
+                                                            );
+                                                        })
+                                                    }),
+                                            ),
+                                    )
                             ),
                     )
                     .when_some(
@@ -1694,48 +1733,42 @@ impl Render for KeymapEditor {
                         |this, exact_match| {
                             this.child(
                                 h_flex()
-                                    .map(|this| {
-                                        if self
-                                            .keybinding_conflict_state
-                                            .any_user_binding_conflicts()
-                                        {
-                                            this.pr(rems_from_px(54.))
-                                        } else {
-                                            this.pr_7()
-                                        }
-                                    })
                                     .gap_2()
                                     .child(self.keystroke_editor.clone())
                                     .child(
-                                        IconButton::new(
-                                            "keystrokes-exact-match",
-                                            IconName::CaseSensitive,
-                                        )
-                                        .tooltip({
-                                            let keystroke_focus_handle =
-                                                self.keystroke_editor.read(cx).focus_handle(cx);
-
-                                            move |window, cx| {
-                                                Tooltip::for_action_in(
-                                                    "Toggle Exact Match Mode",
-                                                    &ToggleExactKeystrokeMatching,
-                                                    &keystroke_focus_handle,
-                                                    window,
-                                                    cx,
+                                        h_flex()
+                                            .min_w_64()
+                                            .child(
+                                                IconButton::new(
+                                                    "keystrokes-exact-match",
+                                                    IconName::CaseSensitive,
                                                 )
-                                            }
-                                        })
-                                        .shape(IconButtonShape::Square)
-                                        .toggle_state(exact_match)
-                                        .on_click(
-                                            cx.listener(|_, _, window, cx| {
-                                                window.dispatch_action(
-                                                    ToggleExactKeystrokeMatching.boxed_clone(),
-                                                    cx,
-                                                );
-                                            }),
-                                        ),
-                                    ),
+                                                .tooltip({
+                                                    let keystroke_focus_handle =
+                                                        self.keystroke_editor.read(cx).focus_handle(cx);
+
+                                                    move |window, cx| {
+                                                        Tooltip::for_action_in(
+                                                            "Toggle Exact Match Mode",
+                                                            &ToggleExactKeystrokeMatching,
+                                                            &keystroke_focus_handle,
+                                                            window,
+                                                            cx,
+                                                        )
+                                                    }
+                                                })
+                                                .shape(IconButtonShape::Square)
+                                                .toggle_state(exact_match)
+                                                .on_click(
+                                                    cx.listener(|_, _, window, cx| {
+                                                        window.dispatch_action(
+                                                            ToggleExactKeystrokeMatching.boxed_clone(),
+                                                            cx,
+                                                        );
+                                                    }),
+                                                ),
+                                            ),
+                                    )
                             )
                         },
                     ),
diff --git a/crates/keymap_editor/src/ui_components/keystroke_input.rs b/crates/keymap_editor/src/ui_components/keystroke_input.rs
index e6b2ff710555403048c56bb1f249d71971d0e91b..e264df3b62bc3c5c78acc38ed906e81837dfbf94 100644
--- a/crates/keymap_editor/src/ui_components/keystroke_input.rs
+++ b/crates/keymap_editor/src/ui_components/keystroke_input.rs
@@ -461,7 +461,7 @@ impl Render for KeystrokeInput {
         let is_focused = self.outer_focus_handle.contains_focused(window, cx);
         let is_recording = self.is_recording(window);
 
-        let horizontal_padding = rems_from_px(64.);
+        let width = rems_from_px(64.);
 
         let recording_bg_color = colors
             .editor_background
@@ -528,6 +528,9 @@ impl Render for KeystrokeInput {
         h_flex()
             .id("keystroke-input")
             .track_focus(&self.outer_focus_handle)
+            .key_context(Self::key_context())
+            .on_action(cx.listener(Self::start_recording))
+            .on_action(cx.listener(Self::clear_keystrokes))
             .py_2()
             .px_3()
             .gap_2()
@@ -535,7 +538,7 @@ impl Render for KeystrokeInput {
             .w_full()
             .flex_1()
             .justify_between()
-            .rounded_sm()
+            .rounded_md()
             .overflow_hidden()
             .map(|this| {
                 if is_recording {
@@ -545,16 +548,16 @@ impl Render for KeystrokeInput {
                 }
             })
             .border_1()
-            .border_color(colors.border_variant)
-            .when(is_focused, |parent| {
-                parent.border_color(colors.border_focused)
+            .map(|this| {
+                if is_focused {
+                    this.border_color(colors.border_focused)
+                } else {
+                    this.border_color(colors.border_variant)
+                }
             })
-            .key_context(Self::key_context())
-            .on_action(cx.listener(Self::start_recording))
-            .on_action(cx.listener(Self::clear_keystrokes))
             .child(
                 h_flex()
-                    .w(horizontal_padding)
+                    .w(width)
                     .gap_0p5()
                     .justify_start()
                     .flex_none()
@@ -573,14 +576,13 @@ impl Render for KeystrokeInput {
                     .id("keystroke-input-inner")
                     .track_focus(&self.inner_focus_handle)
                     .on_modifiers_changed(cx.listener(Self::on_modifiers_changed))
-                    .size_full()
                     .when(!self.search, |this| {
                         this.focus(|mut style| {
                             style.border_color = Some(colors.border_focused);
                             style
                         })
                     })
-                    .w_full()
+                    .size_full()
                     .min_w_0()
                     .justify_center()
                     .flex_wrap()
@@ -589,7 +591,7 @@ impl Render for KeystrokeInput {
             )
             .child(
                 h_flex()
-                    .w(horizontal_padding)
+                    .w(width)
                     .gap_0p5()
                     .justify_end()
                     .flex_none()
@@ -641,9 +643,7 @@ impl Render for KeystrokeInput {
                                 "Clear Keystrokes",
                                 &ClearKeystrokes,
                             ))
-                            .when(!is_recording || !is_focused, |this| {
-                                this.icon_color(Color::Muted)
-                            })
+                            .when(!is_focused, |this| this.icon_color(Color::Muted))
                             .on_click(cx.listener(|this, _event, window, cx| {
                                 this.clear_keystrokes(&ClearKeystrokes, window, cx);
                             })),
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 1f056aacc57338d65705e5b7f4bd91085c6142b4..496f9d60d1ad405f82ab522e9050560ad4e64bf4 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -284,6 +284,14 @@ pub enum Operation {
         /// The language server ID.
         server_id: LanguageServerId,
     },
+
+    /// An update to the line ending type of this buffer.
+    UpdateLineEnding {
+        /// The line ending type.
+        line_ending: LineEnding,
+        /// The buffer's lamport timestamp.
+        lamport_timestamp: clock::Lamport,
+    },
 }
 
 /// An event that occurs in a buffer.
@@ -1240,6 +1248,21 @@ impl Buffer {
         self.syntax_map.lock().language_registry()
     }
 
+    /// Assign the line ending type to the buffer.
+    pub fn set_line_ending(&mut self, line_ending: LineEnding, cx: &mut Context<Self>) {
+        self.text.set_line_ending(line_ending);
+
+        let lamport_timestamp = self.text.lamport_clock.tick();
+        self.send_operation(
+            Operation::UpdateLineEnding {
+                line_ending,
+                lamport_timestamp,
+            },
+            true,
+            cx,
+        );
+    }
+
     /// Assign the buffer a new [`Capability`].
     pub fn set_capability(&mut self, capability: Capability, cx: &mut Context<Self>) {
         if self.capability != capability {
@@ -2557,7 +2580,7 @@ impl Buffer {
             Operation::UpdateSelections { selections, .. } => selections
                 .iter()
                 .all(|s| self.can_resolve(&s.start) && self.can_resolve(&s.end)),
-            Operation::UpdateCompletionTriggers { .. } => true,
+            Operation::UpdateCompletionTriggers { .. } | Operation::UpdateLineEnding { .. } => true,
         }
     }
 
@@ -2623,6 +2646,13 @@ impl Buffer {
                 }
                 self.text.lamport_clock.observe(lamport_timestamp);
             }
+            Operation::UpdateLineEnding {
+                line_ending,
+                lamport_timestamp,
+            } => {
+                self.text.set_line_ending(line_ending);
+                self.text.lamport_clock.observe(lamport_timestamp);
+            }
         }
     }
 
@@ -2842,12 +2872,12 @@ impl Buffer {
 
             let new_start = last_end.map_or(0, |last_end| last_end + 1);
             let mut range = self.random_byte_range(new_start, rng);
-            if rng.gen_bool(0.2) {
+            if rng.random_bool(0.2) {
                 mem::swap(&mut range.start, &mut range.end);
             }
             last_end = Some(range.end);
 
-            let new_text_len = rng.gen_range(0..10);
+            let new_text_len = rng.random_range(0..10);
             let mut new_text: String = RandomCharIter::new(&mut *rng).take(new_text_len).collect();
             new_text = new_text.to_uppercase();
 
@@ -3429,46 +3459,66 @@ impl BufferSnapshot {
     }
 
     /// Returns the closest syntax node enclosing the given range.
+    /// Positions a tree cursor at the leaf node that contains or touches the given range.
+    /// This is shared logic used by syntax navigation methods.
+    fn position_cursor_at_range(cursor: &mut tree_sitter::TreeCursor, range: &Range<usize>) {
+        // Descend to the first leaf that touches the start of the range.
+        //
+        // If the range is non-empty and the current node ends exactly at the start,
+        // move to the next sibling to find a node that extends beyond the start.
+        //
+        // If the range is empty and the current node starts after the range position,
+        // move to the previous sibling to find the node that contains the position.
+        while cursor.goto_first_child_for_byte(range.start).is_some() {
+            if !range.is_empty() && cursor.node().end_byte() == range.start {
+                cursor.goto_next_sibling();
+            }
+            if range.is_empty() && cursor.node().start_byte() > range.start {
+                cursor.goto_previous_sibling();
+            }
+        }
+    }
+
+    /// Moves the cursor to find a node that contains the given range.
+    /// Returns true if such a node is found, false otherwise.
+    /// This is shared logic used by syntax navigation methods.
+    fn find_containing_node(
+        cursor: &mut tree_sitter::TreeCursor,
+        range: &Range<usize>,
+        strict: bool,
+    ) -> bool {
+        loop {
+            let node_range = cursor.node().byte_range();
+
+            if node_range.start <= range.start
+                && node_range.end >= range.end
+                && (!strict || node_range.len() > range.len())
+            {
+                return true;
+            }
+            if !cursor.goto_parent() {
+                return false;
+            }
+        }
+    }
+
     pub fn syntax_ancestor<'a, T: ToOffset>(
         &'a self,
         range: Range<T>,
     ) -> Option<tree_sitter::Node<'a>> {
         let range = range.start.to_offset(self)..range.end.to_offset(self);
         let mut result: Option<tree_sitter::Node<'a>> = None;
-        'outer: for layer in self
+        for layer in self
             .syntax
             .layers_for_range(range.clone(), &self.text, true)
         {
             let mut cursor = layer.node().walk();
 
-            // Descend to the first leaf that touches the start of the range.
-            //
-            // If the range is non-empty and the current node ends exactly at the start,
-            // move to the next sibling to find a node that extends beyond the start.
-            //
-            // If the range is empty and the current node starts after the range position,
-            // move to the previous sibling to find the node that contains the position.
-            while cursor.goto_first_child_for_byte(range.start).is_some() {
-                if !range.is_empty() && cursor.node().end_byte() == range.start {
-                    cursor.goto_next_sibling();
-                }
-                if range.is_empty() && cursor.node().start_byte() > range.start {
-                    cursor.goto_previous_sibling();
-                }
-            }
+            Self::position_cursor_at_range(&mut cursor, &range);
 
             // Ascend to the smallest ancestor that strictly contains the range.
-            loop {
-                let node_range = cursor.node().byte_range();
-                if node_range.start <= range.start
-                    && node_range.end >= range.end
-                    && node_range.len() > range.len()
-                {
-                    break;
-                }
-                if !cursor.goto_parent() {
-                    continue 'outer;
-                }
+            if !Self::find_containing_node(&mut cursor, &range, true) {
+                continue;
             }
 
             let left_node = cursor.node();
@@ -3511,6 +3561,112 @@ impl BufferSnapshot {
         result
     }
 
+    /// Find the previous sibling syntax node at the given range.
+    ///
+    /// This function locates the syntax node that precedes the node containing
+    /// the given range. It searches hierarchically by:
+    /// 1. Finding the node that contains the given range
+    /// 2. Looking for the previous sibling at the same tree level
+    /// 3. If no sibling is found, moving up to parent levels and searching for siblings
+    ///
+    /// Returns `None` if there is no previous sibling at any ancestor level.
+    pub fn syntax_prev_sibling<'a, T: ToOffset>(
+        &'a self,
+        range: Range<T>,
+    ) -> Option<tree_sitter::Node<'a>> {
+        let range = range.start.to_offset(self)..range.end.to_offset(self);
+        let mut result: Option<tree_sitter::Node<'a>> = None;
+
+        for layer in self
+            .syntax
+            .layers_for_range(range.clone(), &self.text, true)
+        {
+            let mut cursor = layer.node().walk();
+
+            Self::position_cursor_at_range(&mut cursor, &range);
+
+            // Find the node that contains the range
+            if !Self::find_containing_node(&mut cursor, &range, false) {
+                continue;
+            }
+
+            // Look for the previous sibling, moving up ancestor levels if needed
+            loop {
+                if cursor.goto_previous_sibling() {
+                    let layer_result = cursor.node();
+
+                    if let Some(previous_result) = &result {
+                        if previous_result.byte_range().end < layer_result.byte_range().end {
+                            continue;
+                        }
+                    }
+                    result = Some(layer_result);
+                    break;
+                }
+
+                // No sibling found at this level, try moving up to parent
+                if !cursor.goto_parent() {
+                    break;
+                }
+            }
+        }
+
+        result
+    }
+
+    /// Find the next sibling syntax node at the given range.
+    ///
+    /// This function locates the syntax node that follows the node containing
+    /// the given range. It searches hierarchically by:
+    /// 1. Finding the node that contains the given range
+    /// 2. Looking for the next sibling at the same tree level
+    /// 3. If no sibling is found, moving up to parent levels and searching for siblings
+    ///
+    /// Returns `None` if there is no next sibling at any ancestor level.
+    pub fn syntax_next_sibling<'a, T: ToOffset>(
+        &'a self,
+        range: Range<T>,
+    ) -> Option<tree_sitter::Node<'a>> {
+        let range = range.start.to_offset(self)..range.end.to_offset(self);
+        let mut result: Option<tree_sitter::Node<'a>> = None;
+
+        for layer in self
+            .syntax
+            .layers_for_range(range.clone(), &self.text, true)
+        {
+            let mut cursor = layer.node().walk();
+
+            Self::position_cursor_at_range(&mut cursor, &range);
+
+            // Find the node that contains the range
+            if !Self::find_containing_node(&mut cursor, &range, false) {
+                continue;
+            }
+
+            // Look for the next sibling, moving up ancestor levels if needed
+            loop {
+                if cursor.goto_next_sibling() {
+                    let layer_result = cursor.node();
+
+                    if let Some(previous_result) = &result {
+                        if previous_result.byte_range().start > layer_result.byte_range().start {
+                            continue;
+                        }
+                    }
+                    result = Some(layer_result);
+                    break;
+                }
+
+                // No sibling found at this level, try moving up to parent
+                if !cursor.goto_parent() {
+                    break;
+                }
+            }
+        }
+
+        result
+    }
+
     /// Returns the root syntax node within the given row
     pub fn syntax_root_ancestor(&self, position: Anchor) -> Option<tree_sitter::Node<'_>> {
         let start_offset = position.to_offset(self);
@@ -4814,6 +4970,9 @@ impl operation_queue::Operation for Operation {
             }
             | Operation::UpdateCompletionTriggers {
                 lamport_timestamp, ..
+            }
+            | Operation::UpdateLineEnding {
+                lamport_timestamp, ..
             } => *lamport_timestamp,
         }
     }
diff --git a/crates/language/src/buffer_tests.rs b/crates/language/src/buffer_tests.rs
index ce65afa6288767766fa9a1da5c3a24f9ca86e580..050ec457dfe6e83d420206b381d5524b9c583441 100644
--- a/crates/language/src/buffer_tests.rs
+++ b/crates/language/src/buffer_tests.rs
@@ -67,6 +67,78 @@ fn test_line_endings(cx: &mut gpui::App) {
     });
 }
 
+#[gpui::test]
+fn test_set_line_ending(cx: &mut TestAppContext) {
+    let base = cx.new(|cx| Buffer::local("one\ntwo\nthree\n", cx));
+    let base_replica = cx.new(|cx| {
+        Buffer::from_proto(1, Capability::ReadWrite, base.read(cx).to_proto(cx), None).unwrap()
+    });
+    base.update(cx, |_buffer, cx| {
+        cx.subscribe(&base_replica, |this, _, event, cx| {
+            if let BufferEvent::Operation {
+                operation,
+                is_local: true,
+            } = event
+            {
+                this.apply_ops([operation.clone()], cx);
+            }
+        })
+        .detach();
+    });
+    base_replica.update(cx, |_buffer, cx| {
+        cx.subscribe(&base, |this, _, event, cx| {
+            if let BufferEvent::Operation {
+                operation,
+                is_local: true,
+            } = event
+            {
+                this.apply_ops([operation.clone()], cx);
+            }
+        })
+        .detach();
+    });
+
+    // Base
+    base_replica.read_with(cx, |buffer, _| {
+        assert_eq!(buffer.line_ending(), LineEnding::Unix);
+    });
+    base.update(cx, |buffer, cx| {
+        assert_eq!(buffer.line_ending(), LineEnding::Unix);
+        buffer.set_line_ending(LineEnding::Windows, cx);
+        assert_eq!(buffer.line_ending(), LineEnding::Windows);
+    });
+    base_replica.read_with(cx, |buffer, _| {
+        assert_eq!(buffer.line_ending(), LineEnding::Windows);
+    });
+    base.update(cx, |buffer, cx| {
+        buffer.set_line_ending(LineEnding::Unix, cx);
+        assert_eq!(buffer.line_ending(), LineEnding::Unix);
+    });
+    base_replica.read_with(cx, |buffer, _| {
+        assert_eq!(buffer.line_ending(), LineEnding::Unix);
+    });
+
+    // Replica
+    base.read_with(cx, |buffer, _| {
+        assert_eq!(buffer.line_ending(), LineEnding::Unix);
+    });
+    base_replica.update(cx, |buffer, cx| {
+        assert_eq!(buffer.line_ending(), LineEnding::Unix);
+        buffer.set_line_ending(LineEnding::Windows, cx);
+        assert_eq!(buffer.line_ending(), LineEnding::Windows);
+    });
+    base.read_with(cx, |buffer, _| {
+        assert_eq!(buffer.line_ending(), LineEnding::Windows);
+    });
+    base_replica.update(cx, |buffer, cx| {
+        buffer.set_line_ending(LineEnding::Unix, cx);
+        assert_eq!(buffer.line_ending(), LineEnding::Unix);
+    });
+    base.read_with(cx, |buffer, _| {
+        assert_eq!(buffer.line_ending(), LineEnding::Unix);
+    });
+}
+
 #[gpui::test]
 fn test_select_language(cx: &mut App) {
     init_settings(cx, |_| {});
@@ -3013,7 +3085,7 @@ fn test_random_collaboration(cx: &mut App, mut rng: StdRng) {
         .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
         .unwrap_or(10);
 
-    let base_text_len = rng.gen_range(0..10);
+    let base_text_len = rng.random_range(0..10);
     let base_text = RandomCharIter::new(&mut rng)
         .take(base_text_len)
         .collect::<String>();
@@ -3022,7 +3094,7 @@ fn test_random_collaboration(cx: &mut App, mut rng: StdRng) {
     let network = Arc::new(Mutex::new(Network::new(rng.clone())));
     let base_buffer = cx.new(|cx| Buffer::local(base_text.as_str(), cx));
 
-    for i in 0..rng.gen_range(min_peers..=max_peers) {
+    for i in 0..rng.random_range(min_peers..=max_peers) {
         let buffer = cx.new(|cx| {
             let state = base_buffer.read(cx).to_proto(cx);
             let ops = cx
@@ -3035,7 +3107,7 @@ fn test_random_collaboration(cx: &mut App, mut rng: StdRng) {
                     .map(|op| proto::deserialize_operation(op).unwrap()),
                 cx,
             );
-            buffer.set_group_interval(Duration::from_millis(rng.gen_range(0..=200)));
+            buffer.set_group_interval(Duration::from_millis(rng.random_range(0..=200)));
             let network = network.clone();
             cx.subscribe(&cx.entity(), move |buffer, _, event, _| {
                 if let BufferEvent::Operation {
@@ -3066,11 +3138,11 @@ fn test_random_collaboration(cx: &mut App, mut rng: StdRng) {
     let mut next_diagnostic_id = 0;
     let mut active_selections = BTreeMap::default();
     loop {
-        let replica_index = rng.gen_range(0..replica_ids.len());
+        let replica_index = rng.random_range(0..replica_ids.len());
         let replica_id = replica_ids[replica_index];
         let buffer = &mut buffers[replica_index];
         let mut new_buffer = None;
-        match rng.gen_range(0..100) {
+        match rng.random_range(0..100) {
             0..=29 if mutation_count != 0 => {
                 buffer.update(cx, |buffer, cx| {
                     buffer.start_transaction_at(now);
@@ -3082,13 +3154,13 @@ fn test_random_collaboration(cx: &mut App, mut rng: StdRng) {
             }
             30..=39 if mutation_count != 0 => {
                 buffer.update(cx, |buffer, cx| {
-                    if rng.gen_bool(0.2) {
+                    if rng.random_bool(0.2) {
                         log::info!("peer {} clearing active selections", replica_id);
                         active_selections.remove(&replica_id);
                         buffer.remove_active_selections(cx);
                     } else {
                         let mut selections = Vec::new();
-                        for id in 0..rng.gen_range(1..=5) {
+                        for id in 0..rng.random_range(1..=5) {
                             let range = buffer.random_byte_range(0, &mut rng);
                             selections.push(Selection {
                                 id,
@@ -3111,7 +3183,7 @@ fn test_random_collaboration(cx: &mut App, mut rng: StdRng) {
                 mutation_count -= 1;
             }
             40..=49 if mutation_count != 0 && replica_id == 0 => {
-                let entry_count = rng.gen_range(1..=5);
+                let entry_count = rng.random_range(1..=5);
                 buffer.update(cx, |buffer, cx| {
                     let diagnostics = DiagnosticSet::new(
                         (0..entry_count).map(|_| {
@@ -3166,7 +3238,7 @@ fn test_random_collaboration(cx: &mut App, mut rng: StdRng) {
                         new_buffer.replica_id(),
                         new_buffer.text()
                     );
-                    new_buffer.set_group_interval(Duration::from_millis(rng.gen_range(0..=200)));
+                    new_buffer.set_group_interval(Duration::from_millis(rng.random_range(0..=200)));
                     let network = network.clone();
                     cx.subscribe(&cx.entity(), move |buffer, _, event, _| {
                         if let BufferEvent::Operation {
@@ -3238,7 +3310,7 @@ fn test_random_collaboration(cx: &mut App, mut rng: StdRng) {
             _ => {}
         }
 
-        now += Duration::from_millis(rng.gen_range(0..=200));
+        now += Duration::from_millis(rng.random_range(0..=200));
         buffers.extend(new_buffer);
 
         for buffer in &buffers {
@@ -3320,23 +3392,23 @@ fn test_trailing_whitespace_ranges(mut rng: StdRng) {
     // Generate a random multi-line string containing
     // some lines with trailing whitespace.
     let mut text = String::new();
-    for _ in 0..rng.gen_range(0..16) {
-        for _ in 0..rng.gen_range(0..36) {
-            text.push(match rng.gen_range(0..10) {
+    for _ in 0..rng.random_range(0..16) {
+        for _ in 0..rng.random_range(0..36) {
+            text.push(match rng.random_range(0..10) {
                 0..=1 => ' ',
                 3 => '\t',
-                _ => rng.gen_range('a'..='z'),
+                _ => rng.random_range('a'..='z'),
             });
         }
         text.push('\n');
     }
 
-    match rng.gen_range(0..10) {
+    match rng.random_range(0..10) {
         // sometimes remove the last newline
         0..=1 => drop(text.pop()), //
 
         // sometimes add extra newlines
-        2..=3 => text.push_str(&"\n".repeat(rng.gen_range(1..5))),
+        2..=3 => text.push_str(&"\n".repeat(rng.random_range(1..5))),
         _ => {}
     }
 
diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs
index e4a1510d7df128158691842206a27844304b3237..256f6d45734ec068f1e038fe0d07049bb732e34b 100644
--- a/crates/language/src/language.rs
+++ b/crates/language/src/language.rs
@@ -69,6 +69,7 @@ pub use text_diff::{
 use theme::SyntaxTheme;
 pub use toolchain::{
     LanguageToolchainStore, LocalLanguageToolchainStore, Toolchain, ToolchainList, ToolchainLister,
+    ToolchainMetadata, ToolchainScope,
 };
 use tree_sitter::{self, Query, QueryCursor, WasmStore, wasmtime};
 use util::serde::default_true;
@@ -589,6 +590,11 @@ pub trait LspAdapter: 'static + Send + Sync {
             "Not implemented for this adapter. This method should only be called on the default JSON language server adapter"
         );
     }
+
+    /// True for the extension adapter and false otherwise.
+    fn is_extension(&self) -> bool {
+        false
+    }
 }
 
 async fn try_fetch_server_binary<L: LspAdapter + 'static + Send + Sync + ?Sized>(
@@ -2269,6 +2275,10 @@ impl LspAdapter for FakeLspAdapter {
         let label_for_completion = self.label_for_completion.as_ref()?;
         label_for_completion(item, language)
     }
+
+    fn is_extension(&self) -> bool {
+        false
+    }
 }
 
 fn get_capture_indices(query: &Query, captures: &mut [(&str, &mut Option<u32>)]) {
diff --git a/crates/language/src/language_registry.rs b/crates/language/src/language_registry.rs
index 4f07240e44599361bf92188fd410dd674745874a..5d9d5529c145a8769d142a1f943b6ae00aeaaeb8 100644
--- a/crates/language/src/language_registry.rs
+++ b/crates/language/src/language_registry.rs
@@ -374,14 +374,23 @@ impl LanguageRegistry {
     pub fn register_available_lsp_adapter(
         &self,
         name: LanguageServerName,
-        load: impl Fn() -> Arc<dyn LspAdapter> + 'static + Send + Sync,
+        adapter: Arc<dyn LspAdapter>,
     ) {
-        self.state.write().available_lsp_adapters.insert(
+        let mut state = self.state.write();
+
+        if adapter.is_extension()
+            && let Some(existing_adapter) = state.all_lsp_adapters.get(&name)
+            && !existing_adapter.adapter.is_extension()
+        {
+            log::warn!(
+                "not registering extension-provided language server {name:?}, since a builtin language server exists with that name",
+            );
+            return;
+        }
+
+        state.available_lsp_adapters.insert(
             name,
-            Arc::new(move || {
-                let lsp_adapter = load();
-                CachedLspAdapter::new(lsp_adapter)
-            }),
+            Arc::new(move || CachedLspAdapter::new(adapter.clone())),
         );
     }
 
@@ -396,13 +405,21 @@ impl LanguageRegistry {
         Some(load_lsp_adapter())
     }
 
-    pub fn register_lsp_adapter(
-        &self,
-        language_name: LanguageName,
-        adapter: Arc<dyn LspAdapter>,
-    ) -> Arc<CachedLspAdapter> {
-        let cached = CachedLspAdapter::new(adapter);
+    pub fn register_lsp_adapter(&self, language_name: LanguageName, adapter: Arc<dyn LspAdapter>) {
         let mut state = self.state.write();
+
+        if adapter.is_extension()
+            && let Some(existing_adapter) = state.all_lsp_adapters.get(&adapter.name())
+            && !existing_adapter.adapter.is_extension()
+        {
+            log::warn!(
+                "not registering extension-provided language server {:?} for language {language_name:?}, since a builtin language server exists with that name",
+                adapter.name(),
+            );
+            return;
+        }
+
+        let cached = CachedLspAdapter::new(adapter);
         state
             .lsp_adapters
             .entry(language_name)
@@ -411,8 +428,6 @@ impl LanguageRegistry {
         state
             .all_lsp_adapters
             .insert(cached.name.clone(), cached.clone());
-
-        cached
     }
 
     /// Register a fake language server and adapter
diff --git a/crates/language/src/language_settings.rs b/crates/language/src/language_settings.rs
index f04b83bc7336143672647a07107fa27bc55f5823..33dd6208a8aa3ce778f6336b1d1189275452dbe2 100644
--- a/crates/language/src/language_settings.rs
+++ b/crates/language/src/language_settings.rs
@@ -17,7 +17,8 @@ use serde::{
 };
 
 use settings::{
-    ParameterizedJsonSchema, Settings, SettingsLocation, SettingsSources, SettingsStore, SettingsUi,
+    ParameterizedJsonSchema, Settings, SettingsKey, SettingsLocation, SettingsSources,
+    SettingsStore, SettingsUi,
 };
 use shellexpand;
 use std::{borrow::Cow, num::NonZeroU32, path::Path, slice, sync::Arc};
@@ -207,7 +208,9 @@ impl LanguageSettings {
 }
 
 /// The provider that supplies edit predictions.
-#[derive(Copy, Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
+#[derive(
+    Copy, Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, JsonSchema, SettingsUi,
+)]
 #[serde(rename_all = "snake_case")]
 pub enum EditPredictionProvider {
     None,
@@ -230,13 +233,14 @@ impl EditPredictionProvider {
 
 /// The settings for edit predictions, such as [GitHub Copilot](https://github.com/features/copilot)
 /// or [Supermaven](https://supermaven.com).
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, SettingsUi)]
 pub struct EditPredictionSettings {
     /// The provider that supplies edit predictions.
     pub provider: EditPredictionProvider,
     /// A list of globs representing files that edit predictions should be disabled for.
     /// This list adds to a pre-existing, sensible default set of globs.
     /// Any additional ones you add are combined with them.
+    #[settings_ui(skip)]
     pub disabled_globs: Vec<DisabledGlob>,
     /// Configures how edit predictions are displayed in the buffer.
     pub mode: EditPredictionsMode,
@@ -268,7 +272,9 @@ pub struct DisabledGlob {
 }
 
 /// The mode in which edit predictions should be displayed.
-#[derive(Copy, Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
+#[derive(
+    Copy, Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, JsonSchema, SettingsUi,
+)]
 #[serde(rename_all = "snake_case")]
 pub enum EditPredictionsMode {
     /// If provider supports it, display inline when holding modifier key (e.g., alt).
@@ -281,18 +287,24 @@ pub enum EditPredictionsMode {
     Eager,
 }
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, SettingsUi)]
 pub struct CopilotSettings {
     /// HTTP/HTTPS proxy to use for Copilot.
+    #[settings_ui(skip)]
     pub proxy: Option<String>,
     /// Disable certificate verification for proxy (not recommended).
     pub proxy_no_verify: Option<bool>,
     /// Enterprise URI for Copilot.
+    #[settings_ui(skip)]
     pub enterprise_uri: Option<String>,
 }
 
 /// The settings for all languages.
-#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, JsonSchema, SettingsUi)]
+#[derive(
+    Debug, Clone, Default, PartialEq, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey,
+)]
+#[settings_key(None)]
+#[settings_ui(group = "Default Language Settings")]
 pub struct AllLanguageSettingsContent {
     /// The settings for enabling/disabling features.
     #[serde(default)]
@@ -309,6 +321,7 @@ pub struct AllLanguageSettingsContent {
     /// Settings for associating file extensions and filenames
     /// with languages.
     #[serde(default)]
+    #[settings_ui(skip)]
     pub file_types: HashMap<Arc<str>, Vec<String>>,
 }
 
@@ -317,6 +330,37 @@ pub struct AllLanguageSettingsContent {
 #[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, JsonSchema)]
 pub struct LanguageToSettingsMap(pub HashMap<LanguageName, LanguageSettingsContent>);
 
+impl SettingsUi for LanguageToSettingsMap {
+    fn settings_ui_item() -> settings::SettingsUiItem {
+        settings::SettingsUiItem::DynamicMap(settings::SettingsUiItemDynamicMap {
+            item: LanguageSettingsContent::settings_ui_item,
+            defaults_path: &[],
+            determine_items: |settings_value, cx| {
+                use settings::SettingsUiEntryMetaData;
+
+                // todo(settings_ui): We should be using a global LanguageRegistry, but it's not implemented yet
+                _ = cx;
+
+                let Some(settings_language_map) = settings_value.as_object() else {
+                    return Vec::new();
+                };
+                let mut languages = Vec::with_capacity(settings_language_map.len());
+
+                for language_name in settings_language_map.keys().map(gpui::SharedString::from) {
+                    languages.push(SettingsUiEntryMetaData {
+                        title: language_name.clone(),
+                        path: language_name,
+                        // todo(settings_ui): Implement documentation for each language
+                        // ideally based on the language's official docs from extension or builtin info
+                        documentation: None,
+                    });
+                }
+                return languages;
+            },
+        })
+    }
+}
+
 inventory::submit! {
     ParameterizedJsonSchema {
         add_and_get_ref: |generator, params, _cx| {
@@ -341,7 +385,7 @@ inventory::submit! {
 }
 
 /// Controls how completions are processed for this language.
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema, SettingsUi)]
 #[serde(rename_all = "snake_case")]
 pub struct CompletionSettings {
     /// Controls how words are completed.
@@ -416,12 +460,14 @@ fn default_3() -> usize {
 }
 
 /// The settings for a particular language.
-#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, JsonSchema, SettingsUi)]
+#[settings_ui(group = "Default")]
 pub struct LanguageSettingsContent {
     /// How many columns a tab should occupy.
     ///
     /// Default: 4
     #[serde(default)]
+    #[settings_ui(skip)]
     pub tab_size: Option<NonZeroU32>,
     /// Whether to indent lines using tab characters, as opposed to multiple
     /// spaces.
@@ -452,6 +498,7 @@ pub struct LanguageSettingsContent {
     ///
     /// Default: []
     #[serde(default)]
+    #[settings_ui(skip)]
     pub wrap_guides: Option<Vec<usize>>,
     /// Indent guide related settings.
     #[serde(default)]
@@ -477,6 +524,7 @@ pub struct LanguageSettingsContent {
     ///
     /// Default: auto
     #[serde(default)]
+    #[settings_ui(skip)]
     pub formatter: Option<SelectedFormatter>,
     /// Zed's Prettier integration settings.
     /// Allows to enable/disable formatting with Prettier
@@ -502,6 +550,7 @@ pub struct LanguageSettingsContent {
     ///
     /// Default: ["..."]
     #[serde(default)]
+    #[settings_ui(skip)]
     pub language_servers: Option<Vec<String>>,
     /// Controls where the `editor::Rewrap` action is allowed for this language.
     ///
@@ -524,6 +573,7 @@ pub struct LanguageSettingsContent {
     ///
     /// Default: []
     #[serde(default)]
+    #[settings_ui(skip)]
     pub edit_predictions_disabled_in: Option<Vec<String>>,
     /// Whether to show tabs and spaces in the editor.
     #[serde(default)]
@@ -563,6 +613,7 @@ pub struct LanguageSettingsContent {
     /// These are not run if formatting is off.
     ///
     /// Default: {} (or {"source.organizeImports": true} for Go).
+    #[settings_ui(skip)]
     pub code_actions_on_format: Option<HashMap<String, bool>>,
     /// Whether to perform linked edits of associated ranges, if the language server supports it.
     /// For example, when editing opening <html> tag, the contents of the closing </html> tag will be edited as well.
@@ -596,11 +647,14 @@ pub struct LanguageSettingsContent {
     /// Preferred debuggers for this language.
     ///
     /// Default: []
+    #[settings_ui(skip)]
     pub debuggers: Option<Vec<String>>,
 }
 
 /// The behavior of `editor::Rewrap`.
-#[derive(Debug, PartialEq, Clone, Copy, Default, Serialize, Deserialize, JsonSchema)]
+#[derive(
+    Debug, PartialEq, Clone, Copy, Default, Serialize, Deserialize, JsonSchema, SettingsUi,
+)]
 #[serde(rename_all = "snake_case")]
 pub enum RewrapBehavior {
     /// Only rewrap within comments.
@@ -613,12 +667,13 @@ pub enum RewrapBehavior {
 }
 
 /// The contents of the edit prediction settings.
-#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema, PartialEq, SettingsUi)]
 pub struct EditPredictionSettingsContent {
     /// A list of globs representing files that edit predictions should be disabled for.
     /// This list adds to a pre-existing, sensible default set of globs.
     /// Any additional ones you add are combined with them.
     #[serde(default)]
+    #[settings_ui(skip)]
     pub disabled_globs: Option<Vec<String>>,
     /// The mode used to display edit predictions in the buffer.
     /// Provider support required.
@@ -633,12 +688,13 @@ pub struct EditPredictionSettingsContent {
     pub enabled_in_text_threads: bool,
 }
 
-#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema, PartialEq, SettingsUi)]
 pub struct CopilotSettingsContent {
     /// HTTP/HTTPS proxy to use for Copilot.
     ///
     /// Default: none
     #[serde(default)]
+    #[settings_ui(skip)]
     pub proxy: Option<String>,
     /// Disable certificate verification for the proxy (not recommended).
     ///
@@ -649,19 +705,21 @@ pub struct CopilotSettingsContent {
     ///
     /// Default: none
     #[serde(default)]
+    #[settings_ui(skip)]
     pub enterprise_uri: Option<String>,
 }
 
 /// The settings for enabling/disabling features.
-#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, JsonSchema, SettingsUi)]
 #[serde(rename_all = "snake_case")]
+#[settings_ui(group = "Features")]
 pub struct FeaturesContent {
     /// Determines which edit prediction provider to use.
     pub edit_prediction_provider: Option<EditPredictionProvider>,
 }
 
 /// Controls the soft-wrapping behavior in the editor.
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema, SettingsUi)]
 #[serde(rename_all = "snake_case")]
 pub enum SoftWrap {
     /// Prefer a single line generally, unless an overly long line is encountered.
@@ -678,7 +736,7 @@ pub enum SoftWrap {
 }
 
 /// Controls the behavior of formatting files when they are saved.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, SettingsUi)]
 pub enum FormatOnSave {
     /// Files should be formatted on save.
     On,
@@ -777,7 +835,7 @@ impl<'de> Deserialize<'de> for FormatOnSave {
 }
 
 /// Controls how whitespace should be displayedin the editor.
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema, SettingsUi)]
 #[serde(rename_all = "snake_case")]
 pub enum ShowWhitespaceSetting {
     /// Draw whitespace only for the selected text.
@@ -798,7 +856,7 @@ pub enum ShowWhitespaceSetting {
 }
 
 /// Controls which formatter should be used when formatting code.
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
+#[derive(Clone, Debug, Default, PartialEq, Eq, SettingsUi)]
 pub enum SelectedFormatter {
     /// Format files using Zed's Prettier integration (if applicable),
     /// or falling back to formatting via language server.
@@ -930,7 +988,9 @@ pub enum Formatter {
 }
 
 /// The settings for indent guides.
-#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[derive(
+    Default, Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, SettingsUi,
+)]
 pub struct IndentGuideSettings {
     /// Whether to display indent guides in the editor.
     ///
@@ -992,7 +1052,7 @@ pub enum IndentGuideBackgroundColoring {
 }
 
 /// The settings for inlay hints.
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq, SettingsUi)]
 pub struct InlayHintSettings {
     /// Global switch to toggle hints on and off.
     ///
@@ -1059,7 +1119,7 @@ fn scroll_debounce_ms() -> u64 {
 }
 
 /// The task settings for a particular language.
-#[derive(Debug, Clone, Deserialize, PartialEq, Serialize, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, PartialEq, Serialize, JsonSchema, SettingsUi)]
 pub struct LanguageTaskConfig {
     /// Extra task variables to set for a particular language.
     #[serde(default)]
@@ -1213,8 +1273,6 @@ impl InlayHintKind {
 }
 
 impl settings::Settings for AllLanguageSettings {
-    const KEY: Option<&'static str> = None;
-
     type FileContent = AllLanguageSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
@@ -1604,7 +1662,7 @@ fn merge_settings(settings: &mut LanguageSettings, src: &LanguageSettingsContent
 /// Allows to enable/disable formatting with Prettier
 /// and configure default Prettier, used when no project-level Prettier installation is found.
 /// Prettier formatting is disabled by default.
-#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, SettingsUi)]
 pub struct PrettierSettings {
     /// Enables or disables formatting with Prettier for a given language.
     #[serde(default)]
@@ -1617,15 +1675,17 @@ pub struct PrettierSettings {
     /// Forces Prettier integration to use specific plugins when formatting files with the language.
     /// The default Prettier will be installed with these plugins.
     #[serde(default)]
+    #[settings_ui(skip)]
     pub plugins: HashSet<String>,
 
     /// Default Prettier options, in the format as in package.json section for Prettier.
     /// If project installs Prettier via its package.json, these options will be ignored.
     #[serde(flatten)]
+    #[settings_ui(skip)]
     pub options: HashMap<String, serde_json::Value>,
 }
 
-#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, SettingsUi)]
 pub struct JsxTagAutoCloseSettings {
     /// Enables or disables auto-closing of JSX tags.
     #[serde(default)]
diff --git a/crates/language/src/proto.rs b/crates/language/src/proto.rs
index 0d5a8e916c8712733dcc7a26faa984453cdd30fd..bc85b10859632fc3e2cf61c663b7159a023f4f3a 100644
--- a/crates/language/src/proto.rs
+++ b/crates/language/src/proto.rs
@@ -90,6 +90,15 @@ pub fn serialize_operation(operation: &crate::Operation) -> proto::Operation {
                     language_server_id: server_id.to_proto(),
                 },
             ),
+
+            crate::Operation::UpdateLineEnding {
+                line_ending,
+                lamport_timestamp,
+            } => proto::operation::Variant::UpdateLineEnding(proto::operation::UpdateLineEnding {
+                replica_id: lamport_timestamp.replica_id as u32,
+                lamport_timestamp: lamport_timestamp.value,
+                line_ending: serialize_line_ending(*line_ending) as i32,
+            }),
         }),
     }
 }
@@ -341,6 +350,18 @@ pub fn deserialize_operation(message: proto::Operation) -> Result<crate::Operati
                     server_id: LanguageServerId::from_proto(message.language_server_id),
                 }
             }
+            proto::operation::Variant::UpdateLineEnding(message) => {
+                crate::Operation::UpdateLineEnding {
+                    lamport_timestamp: clock::Lamport {
+                        replica_id: message.replica_id as ReplicaId,
+                        value: message.lamport_timestamp,
+                    },
+                    line_ending: deserialize_line_ending(
+                        proto::LineEnding::from_i32(message.line_ending)
+                            .context("missing line_ending")?,
+                    ),
+                }
+            }
         },
     )
 }
@@ -496,6 +517,10 @@ pub fn lamport_timestamp_for_operation(operation: &proto::Operation) -> Option<c
             replica_id = op.replica_id;
             value = op.lamport_timestamp;
         }
+        proto::operation::Variant::UpdateLineEnding(op) => {
+            replica_id = op.replica_id;
+            value = op.lamport_timestamp;
+        }
     }
 
     Some(clock::Lamport {
diff --git a/crates/language/src/toolchain.rs b/crates/language/src/toolchain.rs
index 84b10c7961eddb130f88b24c9e3438ff2882f8d3..2cc86881fbd515317d4d6f5949e82eb3da63a1bb 100644
--- a/crates/language/src/toolchain.rs
+++ b/crates/language/src/toolchain.rs
@@ -29,6 +29,40 @@ pub struct Toolchain {
     pub as_json: serde_json::Value,
 }
 
+/// Declares a scope of a toolchain added by user.
+///
+/// When the user adds a toolchain, we give them an option to see that toolchain in:
+/// - All of their projects
+/// - A project they're currently in.
+/// - Only in the subproject they're currently in.
+#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
+pub enum ToolchainScope {
+    Subproject(WorktreeId, Arc<Path>),
+    Project,
+    /// Available in all projects on this box. It wouldn't make sense to show suggestions across machines.
+    Global,
+}
+
+impl ToolchainScope {
+    pub fn label(&self) -> &'static str {
+        match self {
+            ToolchainScope::Subproject(_, _) => "Subproject",
+            ToolchainScope::Project => "Project",
+            ToolchainScope::Global => "Global",
+        }
+    }
+
+    pub fn description(&self) -> &'static str {
+        match self {
+            ToolchainScope::Subproject(_, _) => {
+                "Available only in the subproject you're currently in."
+            }
+            ToolchainScope::Project => "Available in all locations in your current project.",
+            ToolchainScope::Global => "Available in all of your projects on this machine.",
+        }
+    }
+}
+
 impl std::hash::Hash for Toolchain {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
         let Self {
@@ -58,23 +92,41 @@ impl PartialEq for Toolchain {
 }
 
 #[async_trait]
-pub trait ToolchainLister: Send + Sync {
+pub trait ToolchainLister: Send + Sync + 'static {
+    /// List all available toolchains for a given path.
     async fn list(
         &self,
         worktree_root: PathBuf,
         subroot_relative_path: Arc<Path>,
         project_env: Option<HashMap<String, String>>,
     ) -> ToolchainList;
-    // Returns a term which we should use in UI to refer to a toolchain.
-    fn term(&self) -> SharedString;
-    /// Returns the name of the manifest file for this toolchain.
-    fn manifest_name(&self) -> ManifestName;
+
+    /// Given a user-created toolchain, resolve lister-specific details.
+    /// Put another way: fill in the details of the toolchain so the user does not have to.
+    async fn resolve(
+        &self,
+        path: PathBuf,
+        project_env: Option<HashMap<String, String>>,
+    ) -> anyhow::Result<Toolchain>;
+
     async fn activation_script(
         &self,
         toolchain: &Toolchain,
         shell: ShellKind,
         fs: &dyn Fs,
     ) -> Vec<String>;
+    /// Returns various "static" bits of information about this toolchain lister. This function should be pure.
+    fn meta(&self) -> ToolchainMetadata;
+}
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct ToolchainMetadata {
+    /// Returns a term which we should use in UI to refer to toolchains produced by a given `[ToolchainLister]`.
+    pub term: SharedString,
+    /// A user-facing placeholder describing the semantic meaning of a path to a new toolchain.
+    pub new_toolchain_placeholder: SharedString,
+    /// The name of the manifest file for this toolchain.
+    pub manifest_name: ManifestName,
 }
 
 #[async_trait(?Send)]
diff --git a/crates/language_extension/src/extension_lsp_adapter.rs b/crates/language_extension/src/extension_lsp_adapter.rs
index 9b6e467f2f2dfddccaa96d7aaf5d5550d72fe904..c1bc058a344e02fd4830c9db89684579a9e7e045 100644
--- a/crates/language_extension/src/extension_lsp_adapter.rs
+++ b/crates/language_extension/src/extension_lsp_adapter.rs
@@ -398,6 +398,10 @@ impl LspAdapter for ExtensionLspAdapter {
 
         Ok(labels_from_extension(labels, language))
     }
+
+    fn is_extension(&self) -> bool {
+        true
+    }
 }
 
 fn labels_from_extension(
diff --git a/crates/language_model/src/model/cloud_model.rs b/crates/language_model/src/model/cloud_model.rs
index 8a7f3456fbb54826809e8a25c2c767d387afcd4e..c6e146e6b30d70588399274c322e9bf8296709c4 100644
--- a/crates/language_model/src/model/cloud_model.rs
+++ b/crates/language_model/src/model/cloud_model.rs
@@ -36,6 +36,7 @@ impl fmt::Display for ModelRequestLimitReachedError {
             Plan::ZedProTrial => {
                 "Model request limit reached. Upgrade to Zed Pro for more requests."
             }
+            Plan::ZedProV2 | Plan::ZedProTrialV2 => "Model request limit reached.",
         };
 
         write!(f, "{message}")
diff --git a/crates/language_models/src/provider/ollama.rs b/crates/language_models/src/provider/ollama.rs
index 8975115d907875569f63e4247cf7edcdbcb91f8a..a80cacfc4a02521af74b32c34cc3360e9665a7d9 100644
--- a/crates/language_models/src/provider/ollama.rs
+++ b/crates/language_models/src/provider/ollama.rs
@@ -11,8 +11,8 @@ use language_model::{
     LanguageModelToolUseId, MessageContent, RateLimiter, Role, StopReason, TokenUsage,
 };
 use ollama::{
-    ChatMessage, ChatOptions, ChatRequest, ChatResponseDelta, KeepAlive, OllamaFunctionTool,
-    OllamaToolCall, get_models, show_model, stream_chat_completion,
+    ChatMessage, ChatOptions, ChatRequest, ChatResponseDelta, KeepAlive, OllamaFunctionCall,
+    OllamaFunctionTool, OllamaToolCall, get_models, show_model, stream_chat_completion,
 };
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -282,59 +282,85 @@ impl OllamaLanguageModel {
     fn to_ollama_request(&self, request: LanguageModelRequest) -> ChatRequest {
         let supports_vision = self.model.supports_vision.unwrap_or(false);
 
-        ChatRequest {
-            model: self.model.name.clone(),
-            messages: request
-                .messages
-                .into_iter()
-                .map(|msg| {
-                    let images = if supports_vision {
-                        msg.content
-                            .iter()
-                            .filter_map(|content| match content {
-                                MessageContent::Image(image) => Some(image.source.to_string()),
-                                _ => None,
-                            })
-                            .collect::<Vec<String>>()
-                    } else {
-                        vec![]
-                    };
-
-                    match msg.role {
-                        Role::User => ChatMessage::User {
+        let mut messages = Vec::with_capacity(request.messages.len());
+
+        for mut msg in request.messages.into_iter() {
+            let images = if supports_vision {
+                msg.content
+                    .iter()
+                    .filter_map(|content| match content {
+                        MessageContent::Image(image) => Some(image.source.to_string()),
+                        _ => None,
+                    })
+                    .collect::<Vec<String>>()
+            } else {
+                vec![]
+            };
+
+            match msg.role {
+                Role::User => {
+                    for tool_result in msg
+                        .content
+                        .extract_if(.., |x| matches!(x, MessageContent::ToolResult(..)))
+                    {
+                        match tool_result {
+                            MessageContent::ToolResult(tool_result) => {
+                                messages.push(ChatMessage::Tool {
+                                    tool_name: tool_result.tool_name.to_string(),
+                                    content: tool_result.content.to_str().unwrap_or("").to_string(),
+                                })
+                            }
+                            _ => unreachable!("Only tool result should be extracted"),
+                        }
+                    }
+                    if !msg.content.is_empty() {
+                        messages.push(ChatMessage::User {
                             content: msg.string_contents(),
                             images: if images.is_empty() {
                                 None
                             } else {
                                 Some(images)
                             },
-                        },
-                        Role::Assistant => {
-                            let content = msg.string_contents();
-                            let thinking =
-                                msg.content.into_iter().find_map(|content| match content {
-                                    MessageContent::Thinking { text, .. } if !text.is_empty() => {
-                                        Some(text)
-                                    }
-                                    _ => None,
-                                });
-                            ChatMessage::Assistant {
-                                content,
-                                tool_calls: None,
-                                images: if images.is_empty() {
-                                    None
-                                } else {
-                                    Some(images)
-                                },
-                                thinking,
+                        })
+                    }
+                }
+                Role::Assistant => {
+                    let content = msg.string_contents();
+                    let mut thinking = None;
+                    let mut tool_calls = Vec::new();
+                    for content in msg.content.into_iter() {
+                        match content {
+                            MessageContent::Thinking { text, .. } if !text.is_empty() => {
+                                thinking = Some(text)
                             }
+                            MessageContent::ToolUse(tool_use) => {
+                                tool_calls.push(OllamaToolCall::Function(OllamaFunctionCall {
+                                    name: tool_use.name.to_string(),
+                                    arguments: tool_use.input,
+                                }));
+                            }
+                            _ => (),
                         }
-                        Role::System => ChatMessage::System {
-                            content: msg.string_contents(),
-                        },
                     }
-                })
-                .collect(),
+                    messages.push(ChatMessage::Assistant {
+                        content,
+                        tool_calls: Some(tool_calls),
+                        images: if images.is_empty() {
+                            None
+                        } else {
+                            Some(images)
+                        },
+                        thinking,
+                    })
+                }
+                Role::System => messages.push(ChatMessage::System {
+                    content: msg.string_contents(),
+                }),
+            }
+        }
+        ChatRequest {
+            model: self.model.name.clone(),
+            messages,
             keep_alive: self.model.keep_alive.clone().unwrap_or_default(),
             stream: true,
             options: Some(ChatOptions {
@@ -483,6 +509,9 @@ fn map_to_language_model_completion_events(
                 ChatMessage::System { content } => {
                     events.push(Ok(LanguageModelCompletionEvent::Text(content)));
                 }
+                ChatMessage::Tool { content, .. } => {
+                    events.push(Ok(LanguageModelCompletionEvent::Text(content)));
+                }
                 ChatMessage::Assistant {
                     content,
                     tool_calls,
diff --git a/crates/language_models/src/provider/open_ai.rs b/crates/language_models/src/provider/open_ai.rs
index 4348fd42110b2554de801b812a7b001dc49ad06e..fca1cf977cb5e3b32dc6f2335fb0d9188979bc9f 100644
--- a/crates/language_models/src/provider/open_ai.rs
+++ b/crates/language_models/src/provider/open_ai.rs
@@ -56,13 +56,13 @@ pub struct OpenAiLanguageModelProvider {
 pub struct State {
     api_key: Option<String>,
     api_key_from_env: bool,
+    last_api_url: String,
     _subscription: Subscription,
 }
 
 const OPENAI_API_KEY_VAR: &str = "OPENAI_API_KEY";
 
 impl State {
-    //
     fn is_authenticated(&self) -> bool {
         self.api_key.is_some()
     }
@@ -104,11 +104,7 @@ impl State {
         })
     }
 
-    fn authenticate(&self, cx: &mut Context<Self>) -> Task<Result<(), AuthenticateError>> {
-        if self.is_authenticated() {
-            return Task::ready(Ok(()));
-        }
-
+    fn get_api_key(&self, cx: &mut Context<Self>) -> Task<Result<(), AuthenticateError>> {
         let credentials_provider = <dyn CredentialsProvider>::global(cx);
         let api_url = AllLanguageModelSettings::get_global(cx)
             .openai
@@ -136,14 +132,52 @@ impl State {
             Ok(())
         })
     }
+
+    fn authenticate(&self, cx: &mut Context<Self>) -> Task<Result<(), AuthenticateError>> {
+        if self.is_authenticated() {
+            return Task::ready(Ok(()));
+        }
+
+        self.get_api_key(cx)
+    }
 }
 
 impl OpenAiLanguageModelProvider {
     pub fn new(http_client: Arc<dyn HttpClient>, cx: &mut App) -> Self {
+        let initial_api_url = AllLanguageModelSettings::get_global(cx)
+            .openai
+            .api_url
+            .clone();
+
         let state = cx.new(|cx| State {
             api_key: None,
             api_key_from_env: false,
-            _subscription: cx.observe_global::<SettingsStore>(|_this: &mut State, cx| {
+            last_api_url: initial_api_url.clone(),
+            _subscription: cx.observe_global::<SettingsStore>(|this: &mut State, cx| {
+                let current_api_url = AllLanguageModelSettings::get_global(cx)
+                    .openai
+                    .api_url
+                    .clone();
+
+                if this.last_api_url != current_api_url {
+                    this.last_api_url = current_api_url;
+                    if !this.api_key_from_env {
+                        this.api_key = None;
+                        let spawn_task = cx.spawn(async move |handle, cx| {
+                            if let Ok(task) = handle.update(cx, |this, cx| this.get_api_key(cx)) {
+                                if let Err(_) = task.await {
+                                    handle
+                                        .update(cx, |this, _| {
+                                            this.api_key = None;
+                                            this.api_key_from_env = false;
+                                        })
+                                        .ok();
+                                }
+                            }
+                        });
+                        spawn_task.detach();
+                    }
+                }
                 cx.notify();
             }),
         });
@@ -586,7 +620,9 @@ impl OpenAiEventMapper {
         };
 
         if let Some(content) = choice.delta.content.clone() {
-            events.push(Ok(LanguageModelCompletionEvent::Text(content)));
+            if !content.is_empty() {
+                events.push(Ok(LanguageModelCompletionEvent::Text(content)));
+            }
         }
 
         if let Some(tool_calls) = choice.delta.tool_calls.as_ref() {
diff --git a/crates/language_models/src/provider/open_ai_compatible.rs b/crates/language_models/src/provider/open_ai_compatible.rs
index 789eb00a5746c729103f77a1e92d0e58fc4c1ab0..4ebb11a07b66ec7054ca65437ec887a415fa3f5c 100644
--- a/crates/language_models/src/provider/open_ai_compatible.rs
+++ b/crates/language_models/src/provider/open_ai_compatible.rs
@@ -113,11 +113,7 @@ impl State {
         })
     }
 
-    fn authenticate(&self, cx: &mut Context<Self>) -> Task<Result<(), AuthenticateError>> {
-        if self.is_authenticated() {
-            return Task::ready(Ok(()));
-        }
-
+    fn get_api_key(&self, cx: &mut Context<Self>) -> Task<Result<(), AuthenticateError>> {
         let credentials_provider = <dyn CredentialsProvider>::global(cx);
         let env_var_name = self.env_var_name.clone();
         let api_url = self.settings.api_url.clone();
@@ -143,6 +139,14 @@ impl State {
             Ok(())
         })
     }
+
+    fn authenticate(&self, cx: &mut Context<Self>) -> Task<Result<(), AuthenticateError>> {
+        if self.is_authenticated() {
+            return Task::ready(Ok(()));
+        }
+
+        self.get_api_key(cx)
+    }
 }
 
 impl OpenAiCompatibleLanguageModelProvider {
@@ -160,11 +164,27 @@ impl OpenAiCompatibleLanguageModelProvider {
             api_key: None,
             api_key_from_env: false,
             _subscription: cx.observe_global::<SettingsStore>(|this: &mut State, cx| {
-                let Some(settings) = resolve_settings(&this.id, cx) else {
+                let Some(settings) = resolve_settings(&this.id, cx).cloned() else {
                     return;
                 };
-                if &this.settings != settings {
-                    this.settings = settings.clone();
+                if &this.settings != &settings {
+                    if settings.api_url != this.settings.api_url && !this.api_key_from_env {
+                        let spawn_task = cx.spawn(async move |handle, cx| {
+                            if let Ok(task) = handle.update(cx, |this, cx| this.get_api_key(cx)) {
+                                if let Err(_) = task.await {
+                                    handle
+                                        .update(cx, |this, _| {
+                                            this.api_key = None;
+                                            this.api_key_from_env = false;
+                                        })
+                                        .ok();
+                                }
+                            }
+                        });
+                        spawn_task.detach();
+                    }
+
+                    this.settings = settings;
                     cx.notify();
                 }
             }),
diff --git a/crates/language_models/src/provider/open_router.rs b/crates/language_models/src/provider/open_router.rs
index 9138f6b82e7e74e9e6a7468306b2f5cf6768987e..f73a97e6426f80e1ad8d1b8214e16bf361d0f0ce 100644
--- a/crates/language_models/src/provider/open_router.rs
+++ b/crates/language_models/src/provider/open_router.rs
@@ -92,7 +92,7 @@ pub struct State {
     api_key_from_env: bool,
     http_client: Arc<dyn HttpClient>,
     available_models: Vec<open_router::Model>,
-    fetch_models_task: Option<Task<Result<()>>>,
+    fetch_models_task: Option<Task<Result<(), LanguageModelCompletionError>>>,
     settings: OpenRouterSettings,
     _subscription: Subscription,
 }
@@ -178,20 +178,35 @@ impl State {
         })
     }
 
-    fn fetch_models(&mut self, cx: &mut Context<Self>) -> Task<Result<()>> {
+    fn fetch_models(
+        &mut self,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<(), LanguageModelCompletionError>> {
         let settings = &AllLanguageModelSettings::get_global(cx).open_router;
         let http_client = self.http_client.clone();
         let api_url = settings.api_url.clone();
-
+        let Some(api_key) = self.api_key.clone() else {
+            return Task::ready(Err(LanguageModelCompletionError::NoApiKey {
+                provider: PROVIDER_NAME,
+            }));
+        };
         cx.spawn(async move |this, cx| {
-            let models = list_models(http_client.as_ref(), &api_url)
+            let models = list_models(http_client.as_ref(), &api_url, &api_key)
                 .await
-                .map_err(|e| anyhow::anyhow!("OpenRouter error: {:?}", e))?;
+                .map_err(|e| {
+                    LanguageModelCompletionError::Other(anyhow::anyhow!(
+                        "OpenRouter error: {:?}",
+                        e
+                    ))
+                })?;
 
             this.update(cx, |this, cx| {
                 this.available_models = models;
                 cx.notify();
             })
+            .map_err(|e| LanguageModelCompletionError::Other(e))?;
+
+            Ok(())
         })
     }
 
diff --git a/crates/language_models/src/settings.rs b/crates/language_models/src/settings.rs
index 8b7ab5fc2547bd0b014238739f1b940dad831f66..cfe66c91a36d4da562cba84363f79bd1d5b4e1ce 100644
--- a/crates/language_models/src/settings.rs
+++ b/crates/language_models/src/settings.rs
@@ -5,7 +5,7 @@ use collections::HashMap;
 use gpui::App;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 
 use crate::provider::{
     self,
@@ -46,7 +46,10 @@ pub struct AllLanguageModelSettings {
     pub zed_dot_dev: ZedDotDevSettings,
 }
 
-#[derive(Default, Clone, Debug, Serialize, Deserialize, PartialEq, JsonSchema, SettingsUi)]
+#[derive(
+    Default, Clone, Debug, Serialize, Deserialize, PartialEq, JsonSchema, SettingsUi, SettingsKey,
+)]
+#[settings_key(key = "language_models")]
 pub struct AllLanguageModelSettingsContent {
     pub anthropic: Option<AnthropicSettingsContent>,
     pub bedrock: Option<AmazonBedrockSettingsContent>,
@@ -145,8 +148,6 @@ pub struct OpenRouterSettingsContent {
 }
 
 impl settings::Settings for AllLanguageModelSettings {
-    const KEY: Option<&'static str> = Some("language_models");
-
     const PRESERVED_KEYS: Option<&'static [&'static str]> = Some(&["version"]);
 
     type FileContent = AllLanguageModelSettingsContent;
diff --git a/crates/language_onboarding/Cargo.toml b/crates/language_onboarding/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a437adf1191a3b76fbd828dacaa60b75b1f7df28
--- /dev/null
+++ b/crates/language_onboarding/Cargo.toml
@@ -0,0 +1,30 @@
+[package]
+name = "language_onboarding"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/python.rs"
+
+[features]
+default = []
+
+[dependencies]
+db.workspace = true
+editor.workspace = true
+gpui.workspace = true
+project.workspace = true
+ui.workspace = true
+workspace.workspace = true
+workspace-hack.workspace = true
+
+# Uncomment other workspace dependencies as needed
+# assistant.workspace = true
+# client.workspace = true
+# project.workspace = true
+# settings.workspace = true
diff --git a/crates/semantic_index/LICENSE-GPL b/crates/language_onboarding/LICENSE-GPL
similarity index 100%
rename from crates/semantic_index/LICENSE-GPL
rename to crates/language_onboarding/LICENSE-GPL
diff --git a/crates/language_onboarding/src/python.rs b/crates/language_onboarding/src/python.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6b83b841e0488d67014cc090b6c741035e544e04
--- /dev/null
+++ b/crates/language_onboarding/src/python.rs
@@ -0,0 +1,95 @@
+use db::kvp::Dismissable;
+use editor::Editor;
+use gpui::{Context, EventEmitter, Subscription};
+use ui::{Banner, FluentBuilder as _, prelude::*};
+use workspace::{ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView, Workspace};
+
+pub struct BasedPyrightBanner {
+    dismissed: bool,
+    have_basedpyright: bool,
+    _subscriptions: [Subscription; 1],
+}
+
+impl Dismissable for BasedPyrightBanner {
+    const KEY: &str = "basedpyright-banner";
+}
+
+impl BasedPyrightBanner {
+    pub fn new(workspace: &Workspace, cx: &mut Context<Self>) -> Self {
+        let subscription = cx.subscribe(workspace.project(), |this, _, event, _| {
+            if let project::Event::LanguageServerAdded(_, name, _) = event
+                && name == "basedpyright"
+            {
+                this.have_basedpyright = true;
+            }
+        });
+        let dismissed = Self::dismissed();
+        Self {
+            dismissed,
+            have_basedpyright: false,
+            _subscriptions: [subscription],
+        }
+    }
+}
+
+impl EventEmitter<ToolbarItemEvent> for BasedPyrightBanner {}
+
+impl Render for BasedPyrightBanner {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        div()
+            .id("basedpyright-banner")
+            .when(!self.dismissed && self.have_basedpyright, |el| {
+                el.child(
+                    Banner::new()
+                        .child(
+                            v_flex()
+                                .gap_0p5()
+                                .child(Label::new("Basedpyright is now the only default language server for Python").mt_0p5())
+                                .child(Label::new("We have disabled PyRight and pylsp by default. They can be re-enabled in your settings.").size(LabelSize::Small).color(Color::Muted))
+                        )
+                        .action_slot(
+                            h_flex()
+                                .gap_0p5()
+                                .child(
+                                    Button::new("learn-more", "Learn More")
+                                        .icon(IconName::ArrowUpRight)
+                                        .label_size(LabelSize::Small)
+                                        .icon_size(IconSize::XSmall)
+                                        .icon_color(Color::Muted)
+                                        .on_click(|_, _, cx| {
+                                            cx.open_url("https://zed.dev/docs/languages/python")
+                                        }),
+                                )
+                                .child(IconButton::new("dismiss", IconName::Close).icon_size(IconSize::Small).on_click(
+                                    cx.listener(|this, _, _, cx| {
+                                        this.dismissed = true;
+                                        Self::set_dismissed(true, cx);
+                                        cx.notify();
+                                    }),
+                                ))
+                        )
+                        .into_any_element(),
+                )
+            })
+    }
+}
+
+impl ToolbarItemView for BasedPyrightBanner {
+    fn set_active_pane_item(
+        &mut self,
+        active_pane_item: Option<&dyn workspace::ItemHandle>,
+        _window: &mut ui::Window,
+        cx: &mut Context<Self>,
+    ) -> ToolbarItemLocation {
+        if let Some(item) = active_pane_item
+            && let Some(editor) = item.act_as::<Editor>(cx)
+            && let Some(path) = editor.update(cx, |editor, cx| editor.target_file_abs_path(cx))
+            && let Some(file_name) = path.file_name()
+            && file_name.as_encoded_bytes().ends_with(".py".as_bytes())
+        {
+            return ToolbarItemLocation::Secondary;
+        }
+
+        ToolbarItemLocation::Hidden
+    }
+}
diff --git a/crates/language_tools/Cargo.toml b/crates/language_tools/Cargo.toml
index b8f85d8d90068be9ad6849528f28522a96206cc8..bbac900cded75e9ca680a1813734f57423ce0ee9 100644
--- a/crates/language_tools/Cargo.toml
+++ b/crates/language_tools/Cargo.toml
@@ -16,6 +16,7 @@ doctest = false
 anyhow.workspace = true
 client.workspace = true
 collections.workspace = true
+command_palette_hooks.workspace = true
 copilot.workspace = true
 editor.workspace = true
 futures.workspace = true
diff --git a/crates/language_tools/src/lsp_button.rs b/crates/language_tools/src/lsp_button.rs
index f91c4cc61c7e56dc75ad36aa91a4582598995e15..59beceff98ff2544aa22accc470b4e497b88c6ca 100644
--- a/crates/language_tools/src/lsp_button.rs
+++ b/crates/language_tools/src/lsp_button.rs
@@ -296,7 +296,7 @@ impl LanguageServerState {
                                 .update(cx, |workspace, cx| {
                                     workspace
                                         .project()
-                                        .update(cx, |project, cx| project.create_buffer(cx))
+                                        .update(cx, |project, cx| project.create_buffer(false, cx))
                                 })
                                 .ok()
                             else {
diff --git a/crates/language_tools/src/lsp_log_view.rs b/crates/language_tools/src/lsp_log_view.rs
index b1f1e5c4f62b4c14b88cdd3de27a1624c7c7158f..fb63ab9a99147328c4987bd80b698ef4a477f013 100644
--- a/crates/language_tools/src/lsp_log_view.rs
+++ b/crates/language_tools/src/lsp_log_view.rs
@@ -325,7 +325,7 @@ impl LspLogView {
         let server_info = format!(
             "* Server: {NAME} (id {ID})
 
-* Binary: {BINARY:#?}
+* Binary: {BINARY}
 
 * Registered workspace folders:
 {WORKSPACE_FOLDERS}
@@ -335,10 +335,10 @@ impl LspLogView {
 * Configuration: {CONFIGURATION}",
             NAME = info.name,
             ID = info.id,
-            BINARY = info.binary.as_ref().map_or_else(
-                || "Unknown".to_string(),
-                |bin| bin.path.as_path().to_string_lossy().to_string()
-            ),
+            BINARY = info
+                .binary
+                .as_ref()
+                .map_or_else(|| "Unknown".to_string(), |binary| format!("{binary:#?}")),
             WORKSPACE_FOLDERS = info.workspace_folders.join(", "),
             CAPABILITIES = serde_json::to_string_pretty(&info.capabilities)
                 .unwrap_or_else(|e| format!("Failed to serialize capabilities: {e}")),
@@ -990,10 +990,16 @@ impl Render for LspLogToolbarItemView {
             let server_id = server.server_id;
             let rpc_trace_enabled = server.rpc_trace_enabled;
             let log_view = log_view.clone();
+            let label = match server.selected_entry {
+                LogKind::Rpc => RPC_MESSAGES,
+                LogKind::Trace => SERVER_TRACE,
+                LogKind::Logs => SERVER_LOGS,
+                LogKind::ServerInfo => SERVER_INFO,
+            };
             PopoverMenu::new("LspViewSelector")
                 .anchor(Corner::TopLeft)
                 .trigger(
-                    Button::new("language_server_menu_header", server.selected_entry.label())
+                    Button::new("language_server_menu_header", label)
                         .icon(IconName::ChevronDown)
                         .icon_size(IconSize::Small)
                         .icon_color(Color::Muted),
diff --git a/crates/language_tools/src/syntax_tree_view.rs b/crates/language_tools/src/syntax_tree_view.rs
index cf84ac34c4af6d04895ba5d1e22c262a1ef8f03c..5700d8d487e990937597295fb5bab761a46f2ba3 100644
--- a/crates/language_tools/src/syntax_tree_view.rs
+++ b/crates/language_tools/src/syntax_tree_view.rs
@@ -1,17 +1,22 @@
+use command_palette_hooks::CommandPaletteFilter;
 use editor::{Anchor, Editor, ExcerptId, SelectionEffects, scroll::Autoscroll};
 use gpui::{
-    App, AppContext as _, Context, Div, Entity, EventEmitter, FocusHandle, Focusable, Hsla,
-    InteractiveElement, IntoElement, MouseButton, MouseDownEvent, MouseMoveEvent, ParentElement,
-    Render, ScrollStrategy, SharedString, Styled, UniformListScrollHandle, WeakEntity, Window,
-    actions, div, rems, uniform_list,
+    App, AppContext as _, Context, Div, Entity, EntityId, EventEmitter, FocusHandle, Focusable,
+    Hsla, InteractiveElement, IntoElement, MouseButton, MouseDownEvent, MouseMoveEvent,
+    ParentElement, Render, ScrollStrategy, SharedString, Styled, UniformListScrollHandle,
+    WeakEntity, Window, actions, div, rems, uniform_list,
 };
 use language::{Buffer, OwnedSyntaxLayer};
-use std::{mem, ops::Range};
+use std::{any::TypeId, mem, ops::Range};
 use theme::ActiveTheme;
 use tree_sitter::{Node, TreeCursor};
-use ui::{ButtonLike, Color, ContextMenu, Label, LabelCommon, PopoverMenu, h_flex};
+use ui::{
+    ButtonCommon, ButtonLike, Clickable, Color, ContextMenu, FluentBuilder as _, IconButton,
+    IconName, Label, LabelCommon, LabelSize, PopoverMenu, StyledExt, Tooltip, h_flex, v_flex,
+};
 use workspace::{
-    SplitDirection, ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView, Workspace,
+    Event as WorkspaceEvent, SplitDirection, ToolbarItemEvent, ToolbarItemLocation,
+    ToolbarItemView, Workspace,
     item::{Item, ItemHandle},
 };
 
@@ -19,17 +24,51 @@ actions!(
     dev,
     [
         /// Opens the syntax tree view for the current file.
-        OpenSyntaxTreeView
+        OpenSyntaxTreeView,
+    ]
+);
+
+actions!(
+    syntax_tree_view,
+    [
+        /// Update the syntax tree view to show the last focused file.
+        UseActiveEditor
     ]
 );
 
 pub fn init(cx: &mut App) {
-    cx.observe_new(|workspace: &mut Workspace, _, _| {
-        workspace.register_action(|workspace, _: &OpenSyntaxTreeView, window, cx| {
+    let syntax_tree_actions = [TypeId::of::<UseActiveEditor>()];
+
+    CommandPaletteFilter::update_global(cx, |this, _| {
+        this.hide_action_types(&syntax_tree_actions);
+    });
+
+    cx.observe_new(move |workspace: &mut Workspace, _, _| {
+        workspace.register_action(move |workspace, _: &OpenSyntaxTreeView, window, cx| {
+            CommandPaletteFilter::update_global(cx, |this, _| {
+                this.show_action_types(&syntax_tree_actions);
+            });
+
             let active_item = workspace.active_item(cx);
             let workspace_handle = workspace.weak_handle();
-            let syntax_tree_view =
-                cx.new(|cx| SyntaxTreeView::new(workspace_handle, active_item, window, cx));
+            let syntax_tree_view = cx.new(|cx| {
+                cx.on_release(move |view: &mut SyntaxTreeView, cx| {
+                    if view
+                        .workspace_handle
+                        .read_with(cx, |workspace, cx| {
+                            workspace.item_of_type::<SyntaxTreeView>(cx).is_none()
+                        })
+                        .unwrap_or_default()
+                    {
+                        CommandPaletteFilter::update_global(cx, |this, _| {
+                            this.hide_action_types(&syntax_tree_actions);
+                        });
+                    }
+                })
+                .detach();
+
+                SyntaxTreeView::new(workspace_handle, active_item, window, cx)
+            });
             workspace.split_item(
                 SplitDirection::Right,
                 Box::new(syntax_tree_view),
@@ -37,6 +76,13 @@ pub fn init(cx: &mut App) {
                 cx,
             )
         });
+        workspace.register_action(|workspace, _: &UseActiveEditor, window, cx| {
+            if let Some(tree_view) = workspace.item_of_type::<SyntaxTreeView>(cx) {
+                tree_view.update(cx, |view, cx| {
+                    view.update_active_editor(&Default::default(), window, cx)
+                })
+            }
+        });
     })
     .detach();
 }
@@ -45,6 +91,9 @@ pub struct SyntaxTreeView {
     workspace_handle: WeakEntity<Workspace>,
     editor: Option<EditorState>,
     list_scroll_handle: UniformListScrollHandle,
+    /// The last active editor in the workspace. Note that this is specifically not the
+    /// currently shown editor.
+    last_active_editor: Option<Entity<Editor>>,
     selected_descendant_ix: Option<usize>,
     hovered_descendant_ix: Option<usize>,
     focus_handle: FocusHandle,
@@ -61,6 +110,14 @@ struct EditorState {
     _subscription: gpui::Subscription,
 }
 
+impl EditorState {
+    fn has_language(&self) -> bool {
+        self.active_buffer
+            .as_ref()
+            .is_some_and(|buffer| buffer.active_layer.is_some())
+    }
+}
+
 #[derive(Clone)]
 struct BufferState {
     buffer: Entity<Buffer>,
@@ -79,17 +136,25 @@ impl SyntaxTreeView {
             workspace_handle: workspace_handle.clone(),
             list_scroll_handle: UniformListScrollHandle::new(),
             editor: None,
+            last_active_editor: None,
             hovered_descendant_ix: None,
             selected_descendant_ix: None,
             focus_handle: cx.focus_handle(),
         };
 
-        this.workspace_updated(active_item, window, cx);
-        cx.observe_in(
+        this.handle_item_updated(active_item, window, cx);
+
+        cx.subscribe_in(
             &workspace_handle.upgrade().unwrap(),
             window,
-            |this, workspace, window, cx| {
-                this.workspace_updated(workspace.read(cx).active_item(cx), window, cx);
+            move |this, workspace, event, window, cx| match event {
+                WorkspaceEvent::ItemAdded { .. } | WorkspaceEvent::ActiveItemChanged => {
+                    this.handle_item_updated(workspace.read(cx).active_item(cx), window, cx)
+                }
+                WorkspaceEvent::ItemRemoved { item_id } => {
+                    this.handle_item_removed(item_id, window, cx);
+                }
+                _ => {}
             },
         )
         .detach();
@@ -97,20 +162,56 @@ impl SyntaxTreeView {
         this
     }
 
-    fn workspace_updated(
+    fn handle_item_updated(
         &mut self,
         active_item: Option<Box<dyn ItemHandle>>,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        if let Some(item) = active_item
-            && item.item_id() != cx.entity_id()
-            && let Some(editor) = item.act_as::<Editor>(cx)
-        {
+        let Some(editor) = active_item
+            .filter(|item| item.item_id() != cx.entity_id())
+            .and_then(|item| item.act_as::<Editor>(cx))
+        else {
+            return;
+        };
+
+        if let Some(editor_state) = self.editor.as_ref().filter(|state| state.has_language()) {
+            self.last_active_editor = (editor_state.editor != editor).then_some(editor);
+        } else {
             self.set_editor(editor, window, cx);
         }
     }
 
+    fn handle_item_removed(
+        &mut self,
+        item_id: &EntityId,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if self
+            .editor
+            .as_ref()
+            .is_some_and(|state| state.editor.entity_id() == *item_id)
+        {
+            self.editor = None;
+            // Try activating the last active editor if there is one
+            self.update_active_editor(&Default::default(), window, cx);
+            cx.notify();
+        }
+    }
+
+    fn update_active_editor(
+        &mut self,
+        _: &UseActiveEditor,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(editor) = self.last_active_editor.take() else {
+            return;
+        };
+        self.set_editor(editor, window, cx);
+    }
+
     fn set_editor(&mut self, editor: Entity<Editor>, window: &mut Window, cx: &mut Context<Self>) {
         if let Some(state) = &self.editor {
             if state.editor == editor {
@@ -294,101 +395,153 @@ impl SyntaxTreeView {
         .pl(rems(depth as f32))
         .hover(|style| style.bg(colors.element_hover))
     }
-}
-
-impl Render for SyntaxTreeView {
-    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let mut rendered = div().flex_1().bg(cx.theme().colors().editor_background);
 
-        if let Some(layer) = self
-            .editor
-            .as_ref()
-            .and_then(|editor| editor.active_buffer.as_ref())
-            .and_then(|buffer| buffer.active_layer.as_ref())
-        {
-            let layer = layer.clone();
-            rendered = rendered.child(uniform_list(
-                "SyntaxTreeView",
-                layer.node().descendant_count(),
-                cx.processor(move |this, range: Range<usize>, _, cx| {
-                    let mut items = Vec::new();
-                    let mut cursor = layer.node().walk();
-                    let mut descendant_ix = range.start;
-                    cursor.goto_descendant(descendant_ix);
-                    let mut depth = cursor.depth();
-                    let mut visited_children = false;
-                    while descendant_ix < range.end {
-                        if visited_children {
-                            if cursor.goto_next_sibling() {
-                                visited_children = false;
-                            } else if cursor.goto_parent() {
-                                depth -= 1;
-                            } else {
-                                break;
-                            }
-                        } else {
-                            items.push(
-                                Self::render_node(
-                                    &cursor,
-                                    depth,
-                                    Some(descendant_ix) == this.selected_descendant_ix,
+    fn compute_items(
+        &mut self,
+        layer: &OwnedSyntaxLayer,
+        range: Range<usize>,
+        cx: &Context<Self>,
+    ) -> Vec<Div> {
+        let mut items = Vec::new();
+        let mut cursor = layer.node().walk();
+        let mut descendant_ix = range.start;
+        cursor.goto_descendant(descendant_ix);
+        let mut depth = cursor.depth();
+        let mut visited_children = false;
+        while descendant_ix < range.end {
+            if visited_children {
+                if cursor.goto_next_sibling() {
+                    visited_children = false;
+                } else if cursor.goto_parent() {
+                    depth -= 1;
+                } else {
+                    break;
+                }
+            } else {
+                items.push(
+                    Self::render_node(
+                        &cursor,
+                        depth,
+                        Some(descendant_ix) == self.selected_descendant_ix,
+                        cx,
+                    )
+                    .on_mouse_down(
+                        MouseButton::Left,
+                        cx.listener(move |tree_view, _: &MouseDownEvent, window, cx| {
+                            tree_view.update_editor_with_range_for_descendant_ix(
+                                descendant_ix,
+                                window,
+                                cx,
+                                |editor, mut range, window, cx| {
+                                    // Put the cursor at the beginning of the node.
+                                    mem::swap(&mut range.start, &mut range.end);
+
+                                    editor.change_selections(
+                                        SelectionEffects::scroll(Autoscroll::newest()),
+                                        window,
+                                        cx,
+                                        |selections| {
+                                            selections.select_ranges(vec![range]);
+                                        },
+                                    );
+                                },
+                            );
+                        }),
+                    )
+                    .on_mouse_move(cx.listener(
+                        move |tree_view, _: &MouseMoveEvent, window, cx| {
+                            if tree_view.hovered_descendant_ix != Some(descendant_ix) {
+                                tree_view.hovered_descendant_ix = Some(descendant_ix);
+                                tree_view.update_editor_with_range_for_descendant_ix(
+                                    descendant_ix,
+                                    window,
                                     cx,
-                                )
-                                .on_mouse_down(
-                                    MouseButton::Left,
-                                    cx.listener(move |tree_view, _: &MouseDownEvent, window, cx| {
-                                        tree_view.update_editor_with_range_for_descendant_ix(
-                                            descendant_ix,
-                                            window, cx,
-                                            |editor, mut range, window, cx| {
-                                                // Put the cursor at the beginning of the node.
-                                                mem::swap(&mut range.start, &mut range.end);
-
-                                                editor.change_selections(
-                                                    SelectionEffects::scroll(Autoscroll::newest()),
-                                                    window, cx,
-                                                    |selections| {
-                                                        selections.select_ranges(vec![range]);
-                                                    },
-                                                );
+                                    |editor, range, _, cx| {
+                                        editor.clear_background_highlights::<Self>(cx);
+                                        editor.highlight_background::<Self>(
+                                            &[range],
+                                            |theme| {
+                                                theme
+                                                    .colors()
+                                                    .editor_document_highlight_write_background
                                             },
+                                            cx,
                                         );
-                                    }),
-                                )
-                                .on_mouse_move(cx.listener(
-                                    move |tree_view, _: &MouseMoveEvent, window, cx| {
-                                        if tree_view.hovered_descendant_ix != Some(descendant_ix) {
-                                            tree_view.hovered_descendant_ix = Some(descendant_ix);
-                                            tree_view.update_editor_with_range_for_descendant_ix(descendant_ix, window, cx, |editor, range, _, cx| {
-                                                editor.clear_background_highlights::<Self>( cx);
-                                                editor.highlight_background::<Self>(
-                                                    &[range],
-                                                    |theme| theme.colors().editor_document_highlight_write_background,
-                                                     cx,
-                                                );
-                                            });
-                                            cx.notify();
-                                        }
                                     },
-                                )),
-                            );
-                            descendant_ix += 1;
-                            if cursor.goto_first_child() {
-                                depth += 1;
-                            } else {
-                                visited_children = true;
+                                );
+                                cx.notify();
                             }
-                        }
-                    }
-                    items
-                }),
-            )
-            .size_full()
-            .track_scroll(self.list_scroll_handle.clone())
-            .text_bg(cx.theme().colors().background).into_any_element());
+                        },
+                    )),
+                );
+                descendant_ix += 1;
+                if cursor.goto_first_child() {
+                    depth += 1;
+                } else {
+                    visited_children = true;
+                }
+            }
         }
+        items
+    }
+}
 
-        rendered
+impl Render for SyntaxTreeView {
+    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        div()
+            .flex_1()
+            .bg(cx.theme().colors().editor_background)
+            .map(|this| {
+                let editor_state = self.editor.as_ref();
+
+                if let Some(layer) = editor_state
+                    .and_then(|editor| editor.active_buffer.as_ref())
+                    .and_then(|buffer| buffer.active_layer.as_ref())
+                {
+                    let layer = layer.clone();
+                    this.child(
+                        uniform_list(
+                            "SyntaxTreeView",
+                            layer.node().descendant_count(),
+                            cx.processor(move |this, range: Range<usize>, _, cx| {
+                                this.compute_items(&layer, range, cx)
+                            }),
+                        )
+                        .size_full()
+                        .track_scroll(self.list_scroll_handle.clone())
+                        .text_bg(cx.theme().colors().background)
+                        .into_any_element(),
+                    )
+                } else {
+                    let inner_content = v_flex()
+                        .items_center()
+                        .text_center()
+                        .gap_2()
+                        .max_w_3_5()
+                        .map(|this| {
+                            if editor_state.is_some_and(|state| !state.has_language()) {
+                                this.child(Label::new("Current editor has no associated language"))
+                                    .child(
+                                        Label::new(concat!(
+                                            "Try assigning a language or",
+                                            "switching to a different buffer"
+                                        ))
+                                        .size(LabelSize::Small),
+                                    )
+                            } else {
+                                this.child(Label::new("Not attached to an editor")).child(
+                                    Label::new("Focus an editor to show a new tree view")
+                                        .size(LabelSize::Small),
+                                )
+                            }
+                        });
+
+                    this.h_flex()
+                        .size_full()
+                        .justify_center()
+                        .child(inner_content)
+                }
+            })
     }
 }
 
@@ -506,6 +659,26 @@ impl SyntaxTreeToolbarItemView {
             .child(Label::new(active_layer.language.name()))
             .child(Label::new(format_node_range(active_layer.node())))
     }
+
+    fn render_update_button(&mut self, cx: &mut Context<Self>) -> Option<IconButton> {
+        self.tree_view.as_ref().and_then(|view| {
+            view.update(cx, |view, cx| {
+                view.last_active_editor.as_ref().map(|editor| {
+                    IconButton::new("syntax-view-update", IconName::RotateCw)
+                        .tooltip({
+                            let active_tab_name = editor.read_with(cx, |editor, cx| {
+                                editor.tab_content_text(Default::default(), cx)
+                            });
+
+                            Tooltip::text(format!("Update view to '{active_tab_name}'"))
+                        })
+                        .on_click(cx.listener(|this, _, window, cx| {
+                            this.update_active_editor(&Default::default(), window, cx);
+                        }))
+                })
+            })
+        })
+    }
 }
 
 fn format_node_range(node: Node) -> String {
@@ -522,8 +695,10 @@ fn format_node_range(node: Node) -> String {
 
 impl Render for SyntaxTreeToolbarItemView {
     fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        self.render_menu(cx)
-            .unwrap_or_else(|| PopoverMenu::new("Empty Syntax Tree"))
+        h_flex()
+            .gap_1()
+            .children(self.render_menu(cx))
+            .children(self.render_update_button(cx))
     }
 }
 
diff --git a/crates/languages/Cargo.toml b/crates/languages/Cargo.toml
index 8e258180702626bb3dd32b28bfb0e82722a1f12f..e09b27d4742d4660cffb3d86905fb67268e617fa 100644
--- a/crates/languages/Cargo.toml
+++ b/crates/languages/Cargo.toml
@@ -42,7 +42,6 @@ async-trait.workspace = true
 chrono.workspace = true
 collections.workspace = true
 dap.workspace = true
-feature_flags.workspace = true
 futures.workspace = true
 gpui.workspace = true
 http_client.workspace = true
diff --git a/crates/languages/src/go/highlights.scm b/crates/languages/src/go/highlights.scm
index bb0eaab88a1c0c79a04496d453831cf396d706b6..5d630cbdfc746b56320cd5083222897d84dbf528 100644
--- a/crates/languages/src/go/highlights.scm
+++ b/crates/languages/src/go/highlights.scm
@@ -4,6 +4,8 @@
 (field_identifier) @property
 (package_identifier) @namespace
 
+(label_name) @label
+
 (keyed_element
   .
   (literal_element
diff --git a/crates/languages/src/javascript/injections.scm b/crates/languages/src/javascript/injections.scm
index dbec1937b12a24d336d69051d70e45d0eee5b3de..987be660d3c5ebd706284990d7d21a481b24a2af 100644
--- a/crates/languages/src/javascript/injections.scm
+++ b/crates/languages/src/javascript/injections.scm
@@ -73,3 +73,9 @@
   arguments: (arguments (template_string (string_fragment) @injection.content
                               (#set! injection.language "graphql")))
 )
+
+(call_expression
+  function: (identifier) @_name(#match? @_name "^iso$")
+  arguments: (arguments (template_string (string_fragment) @injection.content
+                              (#set! injection.language "isograph")))
+)
diff --git a/crates/languages/src/lib.rs b/crates/languages/src/lib.rs
index 168cf8f57ca25444e54c11bb8e594faa94726b5d..95fe1312183a3412509375050b1e1ff67642ef3e 100644
--- a/crates/languages/src/lib.rs
+++ b/crates/languages/src/lib.rs
@@ -1,5 +1,4 @@
 use anyhow::Context as _;
-use feature_flags::{FeatureFlag, FeatureFlagAppExt as _};
 use gpui::{App, SharedString, UpdateGlobal};
 use node_runtime::NodeRuntime;
 use python::PyprojectTomlManifestProvider;
@@ -54,12 +53,6 @@ pub static LANGUAGE_GIT_COMMIT: std::sync::LazyLock<Arc<Language>> =
         ))
     });
 
-struct BasedPyrightFeatureFlag;
-
-impl FeatureFlag for BasedPyrightFeatureFlag {
-    const NAME: &'static str = "basedpyright";
-}
-
 pub fn init(languages: Arc<LanguageRegistry>, node: NodeRuntime, cx: &mut App) {
     #[cfg(feature = "load-grammars")]
     languages.register_native_grammars([
@@ -97,7 +90,7 @@ pub fn init(languages: Arc<LanguageRegistry>, node: NodeRuntime, cx: &mut App) {
     let python_context_provider = Arc::new(python::PythonContextProvider);
     let python_lsp_adapter = Arc::new(python::PythonLspAdapter::new(node.clone()));
     let basedpyright_lsp_adapter = Arc::new(BasedPyrightLspAdapter::new());
-    let python_toolchain_provider = Arc::new(python::PythonToolchainProvider::default());
+    let python_toolchain_provider = Arc::new(python::PythonToolchainProvider);
     let rust_context_provider = Arc::new(rust::RustContextProvider);
     let rust_lsp_adapter = Arc::new(rust::RustLspAdapter);
     let tailwind_adapter = Arc::new(tailwind::TailwindLspAdapter::new(node.clone()));
@@ -174,7 +167,7 @@ pub fn init(languages: Arc<LanguageRegistry>, node: NodeRuntime, cx: &mut App) {
         },
         LanguageInfo {
             name: "python",
-            adapters: vec![python_lsp_adapter, py_lsp_adapter],
+            adapters: vec![basedpyright_lsp_adapter],
             context: Some(python_context_provider),
             toolchain: Some(python_toolchain_provider),
             manifest_name: Some(SharedString::new_static("pyproject.toml").into()),
@@ -240,17 +233,6 @@ pub fn init(languages: Arc<LanguageRegistry>, node: NodeRuntime, cx: &mut App) {
         );
     }
 
-    let mut basedpyright_lsp_adapter = Some(basedpyright_lsp_adapter);
-    cx.observe_flag::<BasedPyrightFeatureFlag, _>({
-        let languages = languages.clone();
-        move |enabled, _| {
-            if enabled && let Some(adapter) = basedpyright_lsp_adapter.take() {
-                languages.register_available_lsp_adapter(adapter.name(), move || adapter.clone());
-            }
-        }
-    })
-    .detach();
-
     // Register globally available language servers.
     //
     // This will allow users to add support for a built-in language server (e.g., Tailwind)
@@ -267,27 +249,19 @@ pub fn init(languages: Arc<LanguageRegistry>, node: NodeRuntime, cx: &mut App) {
     // ```
     languages.register_available_lsp_adapter(
         LanguageServerName("tailwindcss-language-server".into()),
-        {
-            let adapter = tailwind_adapter.clone();
-            move || adapter.clone()
-        },
+        tailwind_adapter.clone(),
     );
-    languages.register_available_lsp_adapter(LanguageServerName("eslint".into()), {
-        let adapter = eslint_adapter.clone();
-        move || adapter.clone()
-    });
-    languages.register_available_lsp_adapter(LanguageServerName("vtsls".into()), {
-        let adapter = vtsls_adapter;
-        move || adapter.clone()
-    });
+    languages.register_available_lsp_adapter(
+        LanguageServerName("eslint".into()),
+        eslint_adapter.clone(),
+    );
+    languages.register_available_lsp_adapter(LanguageServerName("vtsls".into()), vtsls_adapter);
     languages.register_available_lsp_adapter(
         LanguageServerName("typescript-language-server".into()),
-        {
-            let adapter = typescript_lsp_adapter;
-            move || adapter.clone()
-        },
+        typescript_lsp_adapter,
     );
-
+    languages.register_available_lsp_adapter(python_lsp_adapter.name(), python_lsp_adapter);
+    languages.register_available_lsp_adapter(py_lsp_adapter.name(), py_lsp_adapter);
     // Register Tailwind for the existing languages that should have it by default.
     //
     // This can be driven by the `language_servers` setting once we have a way for
diff --git a/crates/languages/src/python.rs b/crates/languages/src/python.rs
index 5e6f5e414f001209d3b4447ae8326a12953c45ac..978f22d91c26c604ba670d712589199a64275950 100644
--- a/crates/languages/src/python.rs
+++ b/crates/languages/src/python.rs
@@ -5,19 +5,19 @@ use collections::HashMap;
 use futures::AsyncBufReadExt;
 use gpui::{App, Task};
 use gpui::{AsyncApp, SharedString};
-use language::Toolchain;
 use language::ToolchainList;
 use language::ToolchainLister;
 use language::language_settings::language_settings;
 use language::{ContextLocation, LanguageToolchainStore};
 use language::{ContextProvider, LspAdapter, LspAdapterDelegate};
 use language::{LanguageName, ManifestName, ManifestProvider, ManifestQuery};
+use language::{Toolchain, ToolchainMetadata};
 use lsp::LanguageServerBinary;
 use lsp::LanguageServerName;
 use node_runtime::{NodeRuntime, VersionStrategy};
 use pet_core::Configuration;
 use pet_core::os_environment::Environment;
-use pet_core::python_environment::PythonEnvironmentKind;
+use pet_core::python_environment::{PythonEnvironment, PythonEnvironmentKind};
 use project::Fs;
 use project::lsp_store::language_server_settings;
 use serde_json::{Value, json};
@@ -35,7 +35,7 @@ use std::{
     sync::Arc,
 };
 use task::{ShellKind, TaskTemplate, TaskTemplates, VariableName};
-use util::ResultExt;
+use util::{ResultExt, maybe};
 
 pub(crate) struct PyprojectTomlManifestProvider;
 
@@ -688,17 +688,7 @@ fn python_env_kind_display(k: &PythonEnvironmentKind) -> &'static str {
     }
 }
 
-pub(crate) struct PythonToolchainProvider {
-    term: SharedString,
-}
-
-impl Default for PythonToolchainProvider {
-    fn default() -> Self {
-        Self {
-            term: SharedString::new_static("Virtual Environment"),
-        }
-    }
-}
+pub(crate) struct PythonToolchainProvider;
 
 static ENV_PRIORITY_LIST: &[PythonEnvironmentKind] = &[
     // Prioritize non-Conda environments.
@@ -744,9 +734,6 @@ async fn get_worktree_venv_declaration(worktree_root: &Path) -> Option<String> {
 
 #[async_trait]
 impl ToolchainLister for PythonToolchainProvider {
-    fn manifest_name(&self) -> language::ManifestName {
-        ManifestName::from(SharedString::new_static("pyproject.toml"))
-    }
     async fn list(
         &self,
         worktree_root: PathBuf,
@@ -847,32 +834,7 @@ impl ToolchainLister for PythonToolchainProvider {
 
         let mut toolchains: Vec<_> = toolchains
             .into_iter()
-            .filter_map(|toolchain| {
-                let mut name = String::from("Python");
-                if let Some(version) = &toolchain.version {
-                    _ = write!(name, " {version}");
-                }
-
-                let name_and_kind = match (&toolchain.name, &toolchain.kind) {
-                    (Some(name), Some(kind)) => {
-                        Some(format!("({name}; {})", python_env_kind_display(kind)))
-                    }
-                    (Some(name), None) => Some(format!("({name})")),
-                    (None, Some(kind)) => Some(format!("({})", python_env_kind_display(kind))),
-                    (None, None) => None,
-                };
-
-                if let Some(nk) = name_and_kind {
-                    _ = write!(name, " {nk}");
-                }
-
-                Some(Toolchain {
-                    name: name.into(),
-                    path: toolchain.executable.as_ref()?.to_str()?.to_owned().into(),
-                    language_name: LanguageName::new("Python"),
-                    as_json: serde_json::to_value(toolchain.clone()).ok()?,
-                })
-            })
+            .filter_map(venv_to_toolchain)
             .collect();
         toolchains.dedup();
         ToolchainList {
@@ -881,9 +843,34 @@ impl ToolchainLister for PythonToolchainProvider {
             groups: Default::default(),
         }
     }
-    fn term(&self) -> SharedString {
-        self.term.clone()
+    fn meta(&self) -> ToolchainMetadata {
+        ToolchainMetadata {
+            term: SharedString::new_static("Virtual Environment"),
+            new_toolchain_placeholder: SharedString::new_static(
+                "A path to the python3 executable within a virtual environment, or path to virtual environment itself",
+            ),
+            manifest_name: ManifestName::from(SharedString::new_static("pyproject.toml")),
+        }
     }
+
+    async fn resolve(
+        &self,
+        path: PathBuf,
+        env: Option<HashMap<String, String>>,
+    ) -> anyhow::Result<Toolchain> {
+        let env = env.unwrap_or_default();
+        let environment = EnvironmentApi::from_env(&env);
+        let locators = pet::locators::create_locators(
+            Arc::new(pet_conda::Conda::from(&environment)),
+            Arc::new(pet_poetry::Poetry::from(&environment)),
+            &environment,
+        );
+        let toolchain = pet::resolve::resolve_environment(&path, &locators, &environment)
+            .context("Could not find a virtual environment in provided path")?;
+        let venv = toolchain.resolved.unwrap_or(toolchain.discovered);
+        venv_to_toolchain(venv).context("Could not convert a venv into a toolchain")
+    }
+
     async fn activation_script(
         &self,
         toolchain: &Toolchain,
@@ -902,6 +889,13 @@ impl ToolchainLister for PythonToolchainProvider {
                 let env = toolchain.name.as_deref().unwrap_or("default");
                 activation_script.push(format!("pixi shell -e {env}"))
             }
+            Some(PythonEnvironmentKind::Conda) => {
+                if let Some(name) = &toolchain.name {
+                    activation_script.push(format!("conda activate {name}"));
+                } else {
+                    activation_script.push("conda activate".to_string());
+                }
+            }
             Some(PythonEnvironmentKind::Venv | PythonEnvironmentKind::VirtualEnv) => {
                 if let Some(prefix) = &toolchain.prefix {
                     let activate_keyword = match shell {
@@ -949,6 +943,31 @@ impl ToolchainLister for PythonToolchainProvider {
     }
 }
 
+fn venv_to_toolchain(venv: PythonEnvironment) -> Option<Toolchain> {
+    let mut name = String::from("Python");
+    if let Some(ref version) = venv.version {
+        _ = write!(name, " {version}");
+    }
+
+    let name_and_kind = match (&venv.name, &venv.kind) {
+        (Some(name), Some(kind)) => Some(format!("({name}; {})", python_env_kind_display(kind))),
+        (Some(name), None) => Some(format!("({name})")),
+        (None, Some(kind)) => Some(format!("({})", python_env_kind_display(kind))),
+        (None, None) => None,
+    };
+
+    if let Some(nk) = name_and_kind {
+        _ = write!(name, " {nk}");
+    }
+
+    Some(Toolchain {
+        name: name.into(),
+        path: venv.executable.as_ref()?.to_str()?.to_owned().into(),
+        language_name: LanguageName::new("Python"),
+        as_json: serde_json::to_value(venv).ok()?,
+    })
+}
+
 pub struct EnvironmentApi<'a> {
     global_search_locations: Arc<Mutex<Vec<PathBuf>>>,
     project_env: &'a HashMap<String, String>,
@@ -1600,23 +1619,37 @@ impl LspAdapter for BasedPyrightLspAdapter {
                     }
                 }
 
-                // Always set the python interpreter path
-                // Get or create the python section
-                let python = object
+                // Set both pythonPath and defaultInterpreterPath for compatibility
+                if let Some(python) = object
                     .entry("python")
                     .or_insert(Value::Object(serde_json::Map::default()))
                     .as_object_mut()
-                    .unwrap();
-
-                // Set both pythonPath and defaultInterpreterPath for compatibility
-                python.insert(
-                    "pythonPath".to_owned(),
-                    Value::String(interpreter_path.clone()),
-                );
-                python.insert(
-                    "defaultInterpreterPath".to_owned(),
-                    Value::String(interpreter_path),
-                );
+                {
+                    python.insert(
+                        "pythonPath".to_owned(),
+                        Value::String(interpreter_path.clone()),
+                    );
+                    python.insert(
+                        "defaultInterpreterPath".to_owned(),
+                        Value::String(interpreter_path),
+                    );
+                }
+                // Basedpyright by default uses `strict` type checking, we tone it down as to not surpris users
+                maybe!({
+                    let basedpyright = object
+                        .entry("basedpyright")
+                        .or_insert(Value::Object(serde_json::Map::default()));
+                    let analysis = basedpyright
+                        .as_object_mut()?
+                        .entry("analysis")
+                        .or_insert(Value::Object(serde_json::Map::default()));
+                    if let serde_json::map::Entry::Vacant(v) =
+                        analysis.as_object_mut()?.entry("typeCheckingMode")
+                    {
+                        v.insert(Value::String("standard".to_owned()));
+                    }
+                    Some(())
+                });
             }
 
             user_settings
diff --git a/crates/languages/src/rust/highlights.scm b/crates/languages/src/rust/highlights.scm
index ec7e2d42510c58d25f09c13e78d2f75bf7d20b5c..b0daac71a097b922aa810aadef64a18e95b5b649 100644
--- a/crates/languages/src/rust/highlights.scm
+++ b/crates/languages/src/rust/highlights.scm
@@ -5,6 +5,7 @@
 (primitive_type) @type.builtin
 (self) @variable.special
 (field_identifier) @property
+(shorthand_field_identifier) @property
 
 (trait_item name: (type_identifier) @type.interface)
 (impl_item trait: (type_identifier) @type.interface)
diff --git a/crates/languages/src/tsx/injections.scm b/crates/languages/src/tsx/injections.scm
index 9eec01cc8962b6c807db77a5f8bd2ff1707b4a0d..f749aac43a713dadc6abe81a0523f241610b2675 100644
--- a/crates/languages/src/tsx/injections.scm
+++ b/crates/languages/src/tsx/injections.scm
@@ -73,3 +73,9 @@
   arguments: (arguments (template_string (string_fragment) @injection.content
                               (#set! injection.language "graphql")))
 )
+
+(call_expression
+  function: (identifier) @_name(#match? @_name "^iso$")
+  arguments: (arguments (template_string (string_fragment) @injection.content
+                              (#set! injection.language "isograph")))
+)
diff --git a/crates/languages/src/typescript/injections.scm b/crates/languages/src/typescript/injections.scm
index 1ca1e9ad59176cc1df9461d6fe8630179162e45c..331f42fa913ff8ce79bde5c50599e679ef780962 100644
--- a/crates/languages/src/typescript/injections.scm
+++ b/crates/languages/src/typescript/injections.scm
@@ -78,6 +78,12 @@
                               (#set! injection.language "graphql")))
 )
 
+(call_expression
+  function: (identifier) @_name(#match? @_name "^iso$")
+  arguments: (arguments (template_string (string_fragment) @injection.content
+                              (#set! injection.language "isograph")))
+)
+
 ;; Angular Component template injection
 (call_expression
   function: [
diff --git a/crates/line_ending_selector/Cargo.toml b/crates/line_ending_selector/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7c5c8f6d8f3996771f832c28d5d71b857bb0b3b6
--- /dev/null
+++ b/crates/line_ending_selector/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "line_ending_selector"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/line_ending_selector.rs"
+doctest = false
+
+[dependencies]
+editor.workspace = true
+gpui.workspace = true
+language.workspace = true
+picker.workspace = true
+project.workspace = true
+ui.workspace = true
+util.workspace = true
+workspace.workspace = true
+workspace-hack.workspace = true
diff --git a/crates/line_ending_selector/LICENSE-GPL b/crates/line_ending_selector/LICENSE-GPL
new file mode 120000
index 0000000000000000000000000000000000000000..89e542f750cd3860a0598eff0dc34b56d7336dc4
--- /dev/null
+++ b/crates/line_ending_selector/LICENSE-GPL
@@ -0,0 +1 @@
+../../LICENSE-GPL
\ No newline at end of file
diff --git a/crates/line_ending_selector/src/line_ending_selector.rs b/crates/line_ending_selector/src/line_ending_selector.rs
new file mode 100644
index 0000000000000000000000000000000000000000..532f0b051d79e25229d7cb72419ca557edd5b477
--- /dev/null
+++ b/crates/line_ending_selector/src/line_ending_selector.rs
@@ -0,0 +1,192 @@
+use editor::Editor;
+use gpui::{DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, Task, WeakEntity, actions};
+use language::{Buffer, LineEnding};
+use picker::{Picker, PickerDelegate};
+use project::Project;
+use std::sync::Arc;
+use ui::{ListItem, ListItemSpacing, prelude::*};
+use util::ResultExt;
+use workspace::ModalView;
+
+actions!(
+    line_ending,
+    [
+        /// Toggles the line ending selector modal.
+        Toggle
+    ]
+);
+
+pub fn init(cx: &mut App) {
+    cx.observe_new(LineEndingSelector::register).detach();
+}
+
+pub struct LineEndingSelector {
+    picker: Entity<Picker<LineEndingSelectorDelegate>>,
+}
+
+impl LineEndingSelector {
+    fn register(editor: &mut Editor, _window: Option<&mut Window>, cx: &mut Context<Editor>) {
+        let editor_handle = cx.weak_entity();
+        editor
+            .register_action(move |_: &Toggle, window, cx| {
+                Self::toggle(&editor_handle, window, cx);
+            })
+            .detach();
+    }
+
+    fn toggle(editor: &WeakEntity<Editor>, window: &mut Window, cx: &mut App) {
+        let Some((workspace, buffer)) = editor
+            .update(cx, |editor, cx| {
+                Some((editor.workspace()?, editor.active_excerpt(cx)?.1))
+            })
+            .ok()
+            .flatten()
+        else {
+            return;
+        };
+
+        workspace.update(cx, |workspace, cx| {
+            let project = workspace.project().clone();
+            workspace.toggle_modal(window, cx, move |window, cx| {
+                LineEndingSelector::new(buffer, project, window, cx)
+            });
+        })
+    }
+
+    fn new(
+        buffer: Entity<Buffer>,
+        project: Entity<Project>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let line_ending = buffer.read(cx).line_ending();
+        let delegate =
+            LineEndingSelectorDelegate::new(cx.entity().downgrade(), buffer, project, line_ending);
+        let picker = cx.new(|cx| Picker::nonsearchable_uniform_list(delegate, window, cx));
+        Self { picker }
+    }
+}
+
+impl Render for LineEndingSelector {
+    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
+        v_flex().w(rems(34.)).child(self.picker.clone())
+    }
+}
+
+impl Focusable for LineEndingSelector {
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        self.picker.focus_handle(cx)
+    }
+}
+
+impl EventEmitter<DismissEvent> for LineEndingSelector {}
+impl ModalView for LineEndingSelector {}
+
+struct LineEndingSelectorDelegate {
+    line_ending_selector: WeakEntity<LineEndingSelector>,
+    buffer: Entity<Buffer>,
+    project: Entity<Project>,
+    line_ending: LineEnding,
+    matches: Vec<LineEnding>,
+    selected_index: usize,
+}
+
+impl LineEndingSelectorDelegate {
+    fn new(
+        line_ending_selector: WeakEntity<LineEndingSelector>,
+        buffer: Entity<Buffer>,
+        project: Entity<Project>,
+        line_ending: LineEnding,
+    ) -> Self {
+        Self {
+            line_ending_selector,
+            buffer,
+            project,
+            line_ending,
+            matches: vec![LineEnding::Unix, LineEnding::Windows],
+            selected_index: 0,
+        }
+    }
+}
+
+impl PickerDelegate for LineEndingSelectorDelegate {
+    type ListItem = ListItem;
+
+    fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
+        "Select a line ending…".into()
+    }
+
+    fn match_count(&self) -> usize {
+        self.matches.len()
+    }
+
+    fn confirm(&mut self, _: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        if let Some(line_ending) = self.matches.get(self.selected_index) {
+            self.buffer.update(cx, |this, cx| {
+                this.set_line_ending(*line_ending, cx);
+            });
+            let buffer = self.buffer.clone();
+            let project = self.project.clone();
+            cx.defer(move |cx| {
+                project.update(cx, |this, cx| {
+                    this.save_buffer(buffer, cx).detach();
+                });
+            });
+        }
+        self.dismissed(window, cx);
+    }
+
+    fn dismissed(&mut self, _: &mut Window, cx: &mut Context<Picker<Self>>) {
+        self.line_ending_selector
+            .update(cx, |_, cx| cx.emit(DismissEvent))
+            .log_err();
+    }
+
+    fn selected_index(&self) -> usize {
+        self.selected_index
+    }
+
+    fn set_selected_index(
+        &mut self,
+        ix: usize,
+        _window: &mut Window,
+        _: &mut Context<Picker<Self>>,
+    ) {
+        self.selected_index = ix;
+    }
+
+    fn update_matches(
+        &mut self,
+        _query: String,
+        _window: &mut Window,
+        _cx: &mut Context<Picker<Self>>,
+    ) -> gpui::Task<()> {
+        return Task::ready(());
+    }
+
+    fn render_match(
+        &self,
+        ix: usize,
+        selected: bool,
+        _: &mut Window,
+        _: &mut Context<Picker<Self>>,
+    ) -> Option<Self::ListItem> {
+        let line_ending = self.matches[ix];
+        let label = match line_ending {
+            LineEnding::Unix => "LF",
+            LineEnding::Windows => "CRLF",
+        };
+
+        let mut list_item = ListItem::new(ix)
+            .inset(true)
+            .spacing(ListItemSpacing::Sparse)
+            .toggle_state(selected)
+            .child(Label::new(label));
+
+        if self.line_ending == line_ending {
+            list_item = list_item.end_slot(Icon::new(IconName::Check).color(Color::Muted));
+        }
+
+        Some(list_item)
+    }
+}
diff --git a/crates/lsp/src/lsp.rs b/crates/lsp/src/lsp.rs
index 943bdab5ff817da7819590679d19bbe522b47835..7af51ef6fff8bddefac993fb5eb40e10d054977c 100644
--- a/crates/lsp/src/lsp.rs
+++ b/crates/lsp/src/lsp.rs
@@ -166,6 +166,12 @@ impl<'a> From<&'a str> for LanguageServerName {
     }
 }
 
+impl PartialEq<str> for LanguageServerName {
+    fn eq(&self, other: &str) -> bool {
+        self.0 == other
+    }
+}
+
 /// Handle to a language server RPC activity subscription.
 pub enum Subscription {
     Notification {
diff --git a/crates/markdown/src/markdown.rs b/crates/markdown/src/markdown.rs
index 1f607a033ae08b67f1c2cb66d5ed9d9efd316971..4e1d3ac51e148439e57a4a1c305dabc31cbc2046 100644
--- a/crates/markdown/src/markdown.rs
+++ b/crates/markdown/src/markdown.rs
@@ -69,6 +69,7 @@ pub struct MarkdownStyle {
     pub heading_level_styles: Option<HeadingLevelStyles>,
     pub table_overflow_x_scroll: bool,
     pub height_is_multiple_of_line_height: bool,
+    pub prevent_mouse_interaction: bool,
 }
 
 impl Default for MarkdownStyle {
@@ -89,6 +90,7 @@ impl Default for MarkdownStyle {
             heading_level_styles: None,
             table_overflow_x_scroll: false,
             height_is_multiple_of_line_height: false,
+            prevent_mouse_interaction: false,
         }
     }
 }
@@ -575,16 +577,22 @@ impl MarkdownElement {
         window: &mut Window,
         cx: &mut App,
     ) {
+        if self.style.prevent_mouse_interaction {
+            return;
+        }
+
         let is_hovering_link = hitbox.is_hovered(window)
             && !self.markdown.read(cx).selection.pending
             && rendered_text
                 .link_for_position(window.mouse_position())
                 .is_some();
 
-        if is_hovering_link {
-            window.set_cursor_style(CursorStyle::PointingHand, hitbox);
-        } else {
-            window.set_cursor_style(CursorStyle::IBeam, hitbox);
+        if !self.style.prevent_mouse_interaction {
+            if is_hovering_link {
+                window.set_cursor_style(CursorStyle::PointingHand, hitbox);
+            } else {
+                window.set_cursor_style(CursorStyle::IBeam, hitbox);
+            }
         }
 
         let on_open_url = self.on_url_click.take();
diff --git a/crates/markdown_preview/src/markdown_elements.rs b/crates/markdown_preview/src/markdown_elements.rs
index 560e468439efce22aa72d91054d68d491e125b23..b7ec68951e37113c7f0b19df3d1b3457b7dc5535 100644
--- a/crates/markdown_preview/src/markdown_elements.rs
+++ b/crates/markdown_preview/src/markdown_elements.rs
@@ -155,7 +155,7 @@ pub struct ParsedMarkdownText {
     /// Where the text is located in the source Markdown document.
     pub source_range: Range<usize>,
     /// The text content stripped of any formatting symbols.
-    pub contents: String,
+    pub contents: SharedString,
     /// The list of highlights contained in the Markdown document.
     pub highlights: Vec<(Range<usize>, MarkdownHighlight)>,
     /// The regions of the various ranges in the Markdown document.
diff --git a/crates/markdown_preview/src/markdown_parser.rs b/crates/markdown_preview/src/markdown_parser.rs
index 1b116c50d9820dc4fea9d6b2e5816543d75e7d52..d47db4dfe44b34e94f98c31db137556a007987b0 100644
--- a/crates/markdown_preview/src/markdown_parser.rs
+++ b/crates/markdown_preview/src/markdown_parser.rs
@@ -353,7 +353,7 @@ impl<'a> MarkdownParser<'a> {
                         if !text.is_empty() {
                             let parsed_regions = MarkdownParagraphChunk::Text(ParsedMarkdownText {
                                 source_range: source_range.clone(),
-                                contents: text.clone(),
+                                contents: text.into(),
                                 highlights: highlights.clone(),
                                 region_ranges: region_ranges.clone(),
                                 regions: regions.clone(),
@@ -408,7 +408,7 @@ impl<'a> MarkdownParser<'a> {
         if !text.is_empty() {
             markdown_text_like.push(MarkdownParagraphChunk::Text(ParsedMarkdownText {
                 source_range,
-                contents: text,
+                contents: text.into(),
                 highlights,
                 regions,
                 region_ranges,
@@ -808,15 +808,14 @@ impl<'a> MarkdownParser<'a> {
             markup5ever_rcdom::NodeData::Document => {
                 self.consume_children(source_range, node, elements);
             }
-            markup5ever_rcdom::NodeData::Doctype { .. } => {}
             markup5ever_rcdom::NodeData::Text { contents } => {
                 elements.push(ParsedMarkdownElement::Paragraph(vec![
                     MarkdownParagraphChunk::Text(ParsedMarkdownText {
                         source_range,
-                        contents: contents.borrow().to_string(),
-                        highlights: Vec::default(),
-                        region_ranges: Vec::default(),
                         regions: Vec::default(),
+                        region_ranges: Vec::default(),
+                        highlights: Vec::default(),
+                        contents: contents.borrow().to_string().into(),
                     }),
                 ]));
             }
@@ -826,11 +825,64 @@ impl<'a> MarkdownParser<'a> {
                     if let Some(image) = self.extract_image(source_range, attrs) {
                         elements.push(ParsedMarkdownElement::Image(image));
                     }
+                } else if local_name!("p") == name.local {
+                    self.parse_paragraph(
+                        source_range,
+                        node,
+                        &mut MarkdownParagraph::new(),
+                        elements,
+                    );
                 } else {
                     self.consume_children(source_range, node, elements);
                 }
             }
-            markup5ever_rcdom::NodeData::ProcessingInstruction { .. } => {}
+            _ => {}
+        }
+    }
+
+    fn parse_paragraph(
+        &self,
+        source_range: Range<usize>,
+        node: &Rc<markup5ever_rcdom::Node>,
+        paragraph: &mut MarkdownParagraph,
+        elements: &mut Vec<ParsedMarkdownElement>,
+    ) {
+        match &node.data {
+            markup5ever_rcdom::NodeData::Text { contents } => {
+                paragraph.push(MarkdownParagraphChunk::Text(ParsedMarkdownText {
+                    source_range,
+                    regions: Vec::default(),
+                    region_ranges: Vec::default(),
+                    highlights: Vec::default(),
+                    contents: contents.borrow().to_string().into(),
+                }));
+            }
+            markup5ever_rcdom::NodeData::Element { name, attrs, .. } => {
+                if local_name!("img") == name.local {
+                    if let Some(image) = self.extract_image(source_range, attrs) {
+                        paragraph.push(MarkdownParagraphChunk::Image(image));
+                    }
+                } else {
+                    self.consume_paragraph(source_range, node, paragraph, elements);
+
+                    if !paragraph.is_empty() {
+                        elements.push(ParsedMarkdownElement::Paragraph(std::mem::take(paragraph)));
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn consume_paragraph(
+        &self,
+        source_range: Range<usize>,
+        node: &Rc<markup5ever_rcdom::Node>,
+        paragraph: &mut MarkdownParagraph,
+        elements: &mut Vec<ParsedMarkdownElement>,
+    ) {
+        for node in node.children.borrow().iter() {
+            self.parse_paragraph(source_range.clone(), node, paragraph, elements);
         }
     }
 
@@ -895,14 +947,14 @@ impl<'a> MarkdownParser<'a> {
 
         if let Some(width) = Self::attr_value(attrs, local_name!("width"))
             .or_else(|| styles.get("width").cloned())
-            .and_then(|width| Self::parse_length(&width))
+            .and_then(|width| Self::parse_html_element_dimension(&width))
         {
             image.set_width(width);
         }
 
         if let Some(height) = Self::attr_value(attrs, local_name!("height"))
             .or_else(|| styles.get("height").cloned())
-            .and_then(|height| Self::parse_length(&height))
+            .and_then(|height| Self::parse_html_element_dimension(&height))
         {
             image.set_height(height);
         }
@@ -910,8 +962,7 @@ impl<'a> MarkdownParser<'a> {
         Some(image)
     }
 
-    /// Parses the width/height attribute value of an html element (e.g. img element)
-    fn parse_length(value: &str) -> Option<DefiniteLength> {
+    fn parse_html_element_dimension(value: &str) -> Option<DefiniteLength> {
         if value.ends_with("%") {
             value
                 .trim_end_matches("%")
@@ -1010,7 +1061,7 @@ mod tests {
             ParsedMarkdownElement::Paragraph(vec![MarkdownParagraphChunk::Text(
                 ParsedMarkdownText {
                     source_range: 0..35,
-                    contents: "Some bostrikethroughld text".to_string(),
+                    contents: "Some bostrikethroughld text".into(),
                     highlights: Vec::new(),
                     region_ranges: Vec::new(),
                     regions: Vec::new(),
@@ -1184,7 +1235,7 @@ mod tests {
                 }),
                 MarkdownParagraphChunk::Text(ParsedMarkdownText {
                     source_range: 0..81,
-                    contents: " Lorem Ipsum ".to_string(),
+                    contents: " Lorem Ipsum ".into(),
                     highlights: Vec::new(),
                     region_ranges: Vec::new(),
                     regions: Vec::new(),
@@ -1203,90 +1254,130 @@ mod tests {
     }
 
     #[test]
-    fn test_parse_length() {
+    fn test_parse_html_element_dimension() {
         // Test percentage values
         assert_eq!(
-            MarkdownParser::parse_length("50%"),
+            MarkdownParser::parse_html_element_dimension("50%"),
             Some(DefiniteLength::Fraction(0.5))
         );
         assert_eq!(
-            MarkdownParser::parse_length("100%"),
+            MarkdownParser::parse_html_element_dimension("100%"),
             Some(DefiniteLength::Fraction(1.0))
         );
         assert_eq!(
-            MarkdownParser::parse_length("25%"),
+            MarkdownParser::parse_html_element_dimension("25%"),
             Some(DefiniteLength::Fraction(0.25))
         );
         assert_eq!(
-            MarkdownParser::parse_length("0%"),
+            MarkdownParser::parse_html_element_dimension("0%"),
             Some(DefiniteLength::Fraction(0.0))
         );
 
         // Test pixel values
         assert_eq!(
-            MarkdownParser::parse_length("100px"),
+            MarkdownParser::parse_html_element_dimension("100px"),
             Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(100.0))))
         );
         assert_eq!(
-            MarkdownParser::parse_length("50px"),
+            MarkdownParser::parse_html_element_dimension("50px"),
             Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(50.0))))
         );
         assert_eq!(
-            MarkdownParser::parse_length("0px"),
+            MarkdownParser::parse_html_element_dimension("0px"),
             Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(0.0))))
         );
 
         // Test values without units (should be treated as pixels)
         assert_eq!(
-            MarkdownParser::parse_length("100"),
+            MarkdownParser::parse_html_element_dimension("100"),
             Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(100.0))))
         );
         assert_eq!(
-            MarkdownParser::parse_length("42"),
+            MarkdownParser::parse_html_element_dimension("42"),
             Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(42.0))))
         );
 
         // Test invalid values
-        assert_eq!(MarkdownParser::parse_length("invalid"), None);
-        assert_eq!(MarkdownParser::parse_length("px"), None);
-        assert_eq!(MarkdownParser::parse_length("%"), None);
-        assert_eq!(MarkdownParser::parse_length(""), None);
-        assert_eq!(MarkdownParser::parse_length("abc%"), None);
-        assert_eq!(MarkdownParser::parse_length("abcpx"), None);
+        assert_eq!(
+            MarkdownParser::parse_html_element_dimension("invalid"),
+            None
+        );
+        assert_eq!(MarkdownParser::parse_html_element_dimension("px"), None);
+        assert_eq!(MarkdownParser::parse_html_element_dimension("%"), None);
+        assert_eq!(MarkdownParser::parse_html_element_dimension(""), None);
+        assert_eq!(MarkdownParser::parse_html_element_dimension("abc%"), None);
+        assert_eq!(MarkdownParser::parse_html_element_dimension("abcpx"), None);
 
         // Test decimal values
         assert_eq!(
-            MarkdownParser::parse_length("50.5%"),
+            MarkdownParser::parse_html_element_dimension("50.5%"),
             Some(DefiniteLength::Fraction(0.505))
         );
         assert_eq!(
-            MarkdownParser::parse_length("100.25px"),
+            MarkdownParser::parse_html_element_dimension("100.25px"),
             Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(100.25))))
         );
         assert_eq!(
-            MarkdownParser::parse_length("42.0"),
+            MarkdownParser::parse_html_element_dimension("42.0"),
             Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(42.0))))
         );
     }
 
+    #[gpui::test]
+    async fn test_inline_html_image_tag() {
+        let parsed =
+            parse("<p>Some text<img src=\"http://example.com/foo.png\" /> some more text</p>")
+                .await;
+
+        assert_eq!(
+            ParsedMarkdown {
+                children: vec![ParsedMarkdownElement::Paragraph(vec![
+                    MarkdownParagraphChunk::Text(ParsedMarkdownText {
+                        source_range: 0..71,
+                        contents: "Some text".into(),
+                        highlights: Default::default(),
+                        region_ranges: Default::default(),
+                        regions: Default::default()
+                    }),
+                    MarkdownParagraphChunk::Image(Image {
+                        source_range: 0..71,
+                        link: Link::Web {
+                            url: "http://example.com/foo.png".to_string(),
+                        },
+                        alt_text: None,
+                        height: None,
+                        width: None,
+                    }),
+                    MarkdownParagraphChunk::Text(ParsedMarkdownText {
+                        source_range: 0..71,
+                        contents: " some more text".into(),
+                        highlights: Default::default(),
+                        region_ranges: Default::default(),
+                        regions: Default::default()
+                    }),
+                ])]
+            },
+            parsed
+        );
+    }
+
     #[gpui::test]
     async fn test_html_image_tag() {
         let parsed = parse("<img src=\"http://example.com/foo.png\" />").await;
 
-        let ParsedMarkdownElement::Image(image) = &parsed.children[0] else {
-            panic!("Expected a image element");
-        };
         assert_eq!(
-            image.clone(),
-            Image {
-                source_range: 0..40,
-                link: Link::Web {
-                    url: "http://example.com/foo.png".to_string(),
-                },
-                alt_text: None,
-                height: None,
-                width: None,
+            ParsedMarkdown {
+                children: vec![ParsedMarkdownElement::Image(Image {
+                    source_range: 0..40,
+                    link: Link::Web {
+                        url: "http://example.com/foo.png".to_string(),
+                    },
+                    alt_text: None,
+                    height: None,
+                    width: None,
+                })]
             },
+            parsed
         );
     }
 
@@ -1294,20 +1385,19 @@ mod tests {
     async fn test_html_image_tag_with_alt_text() {
         let parsed = parse("<img src=\"http://example.com/foo.png\" alt=\"Foo\" />").await;
 
-        let ParsedMarkdownElement::Image(image) = &parsed.children[0] else {
-            panic!("Expected a image element");
-        };
         assert_eq!(
-            image.clone(),
-            Image {
-                source_range: 0..50,
-                link: Link::Web {
-                    url: "http://example.com/foo.png".to_string(),
-                },
-                alt_text: Some("Foo".into()),
-                height: None,
-                width: None,
+            ParsedMarkdown {
+                children: vec![ParsedMarkdownElement::Image(Image {
+                    source_range: 0..50,
+                    link: Link::Web {
+                        url: "http://example.com/foo.png".to_string(),
+                    },
+                    alt_text: Some("Foo".into()),
+                    height: None,
+                    width: None,
+                })]
             },
+            parsed
         );
     }
 
@@ -1316,20 +1406,19 @@ mod tests {
         let parsed =
             parse("<img src=\"http://example.com/foo.png\" height=\"100\" width=\"200\" />").await;
 
-        let ParsedMarkdownElement::Image(image) = &parsed.children[0] else {
-            panic!("Expected a image element");
-        };
         assert_eq!(
-            image.clone(),
-            Image {
-                source_range: 0..65,
-                link: Link::Web {
-                    url: "http://example.com/foo.png".to_string(),
-                },
-                alt_text: None,
-                height: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(100.)))),
-                width: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(200.)))),
+            ParsedMarkdown {
+                children: vec![ParsedMarkdownElement::Image(Image {
+                    source_range: 0..65,
+                    link: Link::Web {
+                        url: "http://example.com/foo.png".to_string(),
+                    },
+                    alt_text: None,
+                    height: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(100.)))),
+                    width: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(200.)))),
+                })]
             },
+            parsed
         );
     }
 
@@ -1340,20 +1429,19 @@ mod tests {
         )
         .await;
 
-        let ParsedMarkdownElement::Image(image) = &parsed.children[0] else {
-            panic!("Expected a image element");
-        };
         assert_eq!(
-            image.clone(),
-            Image {
-                source_range: 0..75,
-                link: Link::Web {
-                    url: "http://example.com/foo.png".to_string(),
-                },
-                alt_text: None,
-                height: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(100.)))),
-                width: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(200.)))),
+            ParsedMarkdown {
+                children: vec![ParsedMarkdownElement::Image(Image {
+                    source_range: 0..75,
+                    link: Link::Web {
+                        url: "http://example.com/foo.png".to_string(),
+                    },
+                    alt_text: None,
+                    height: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(100.)))),
+                    width: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(200.)))),
+                })]
             },
+            parsed
         );
     }
 
@@ -1804,7 +1892,7 @@ fn main() {
             region_ranges: Vec::new(),
             regions: Vec::new(),
             source_range,
-            contents: contents.to_string(),
+            contents: contents.to_string().into(),
         })]
     }
 
diff --git a/crates/markdown_preview/src/markdown_renderer.rs b/crates/markdown_preview/src/markdown_renderer.rs
index b07b4686a4eaebdfaef804ba903b6575f56ae479..4525db383514081cbc16b73a32995d59768e4e01 100644
--- a/crates/markdown_preview/src/markdown_renderer.rs
+++ b/crates/markdown_preview/src/markdown_renderer.rs
@@ -277,7 +277,11 @@ fn render_markdown_list_item(
         .items_start()
         .children(vec![
             bullet,
-            div().children(contents).pr(cx.scaled_rems(1.0)).w_full(),
+            v_flex()
+                .children(contents)
+                .gap(cx.scaled_rems(1.0))
+                .pr(cx.scaled_rems(1.0))
+                .w_full(),
         ]);
 
     cx.with_common_p(item).into_any()
@@ -624,15 +628,13 @@ fn render_markdown_code_block(
 }
 
 fn render_markdown_paragraph(parsed: &MarkdownParagraph, cx: &mut RenderContext) -> AnyElement {
-    cx.with_common_p(div())
+    cx.with_common_p(h_flex().flex_wrap())
         .children(render_markdown_text(parsed, cx))
-        .flex()
-        .flex_col()
         .into_any_element()
 }
 
 fn render_markdown_text(parsed_new: &MarkdownParagraph, cx: &mut RenderContext) -> Vec<AnyElement> {
-    let mut any_element = vec![];
+    let mut any_element = Vec::with_capacity(parsed_new.len());
     // these values are cloned in-order satisfy borrow checker
     let syntax_theme = cx.syntax_theme.clone();
     let workspace_clone = cx.workspace.clone();
diff --git a/crates/multi_buffer/src/multi_buffer.rs b/crates/multi_buffer/src/multi_buffer.rs
index a2f28215b4655b12095da96c033d23cb3f13eb77..f5955ec176805433e5c10fec723fa3974baf7a70 100644
--- a/crates/multi_buffer/src/multi_buffer.rs
+++ b/crates/multi_buffer/src/multi_buffer.rs
@@ -3580,7 +3580,7 @@ impl MultiBuffer {
     pub fn build_random(rng: &mut impl rand::Rng, cx: &mut gpui::App) -> Entity<Self> {
         cx.new(|cx| {
             let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
-            let mutation_count = rng.gen_range(1..=5);
+            let mutation_count = rng.random_range(1..=5);
             multibuffer.randomly_edit_excerpts(rng, mutation_count, cx);
             multibuffer
         })
@@ -3603,16 +3603,17 @@ impl MultiBuffer {
             }
 
             let new_start = last_end.map_or(0, |last_end| last_end + 1);
-            let end = snapshot.clip_offset(rng.gen_range(new_start..=snapshot.len()), Bias::Right);
-            let start = snapshot.clip_offset(rng.gen_range(new_start..=end), Bias::Right);
+            let end =
+                snapshot.clip_offset(rng.random_range(new_start..=snapshot.len()), Bias::Right);
+            let start = snapshot.clip_offset(rng.random_range(new_start..=end), Bias::Right);
             last_end = Some(end);
 
             let mut range = start..end;
-            if rng.gen_bool(0.2) {
+            if rng.random_bool(0.2) {
                 mem::swap(&mut range.start, &mut range.end);
             }
 
-            let new_text_len = rng.gen_range(0..10);
+            let new_text_len = rng.random_range(0..10);
             let new_text: String = RandomCharIter::new(&mut *rng).take(new_text_len).collect();
 
             edits.push((range, new_text.into()));
@@ -3639,18 +3640,18 @@ impl MultiBuffer {
 
         let mut buffers = Vec::new();
         for _ in 0..mutation_count {
-            if rng.gen_bool(0.05) {
+            if rng.random_bool(0.05) {
                 log::info!("Clearing multi-buffer");
                 self.clear(cx);
                 continue;
-            } else if rng.gen_bool(0.1) && !self.excerpt_ids().is_empty() {
+            } else if rng.random_bool(0.1) && !self.excerpt_ids().is_empty() {
                 let ids = self.excerpt_ids();
                 let mut excerpts = HashSet::default();
-                for _ in 0..rng.gen_range(0..ids.len()) {
+                for _ in 0..rng.random_range(0..ids.len()) {
                     excerpts.extend(ids.choose(rng).copied());
                 }
 
-                let line_count = rng.gen_range(0..5);
+                let line_count = rng.random_range(0..5);
 
                 log::info!("Expanding excerpts {excerpts:?} by {line_count} lines");
 
@@ -3664,8 +3665,8 @@ impl MultiBuffer {
             }
 
             let excerpt_ids = self.excerpt_ids();
-            if excerpt_ids.is_empty() || (rng.r#gen() && excerpt_ids.len() < max_excerpts) {
-                let buffer_handle = if rng.r#gen() || self.buffers.borrow().is_empty() {
+            if excerpt_ids.is_empty() || (rng.random() && excerpt_ids.len() < max_excerpts) {
+                let buffer_handle = if rng.random() || self.buffers.borrow().is_empty() {
                     let text = RandomCharIter::new(&mut *rng).take(10).collect::<String>();
                     buffers.push(cx.new(|cx| Buffer::local(text, cx)));
                     let buffer = buffers.last().unwrap().read(cx);
@@ -3687,11 +3688,11 @@ impl MultiBuffer {
 
                 let buffer = buffer_handle.read(cx);
                 let buffer_text = buffer.text();
-                let ranges = (0..rng.gen_range(0..5))
+                let ranges = (0..rng.random_range(0..5))
                     .map(|_| {
                         let end_ix =
-                            buffer.clip_offset(rng.gen_range(0..=buffer.len()), Bias::Right);
-                        let start_ix = buffer.clip_offset(rng.gen_range(0..=end_ix), Bias::Left);
+                            buffer.clip_offset(rng.random_range(0..=buffer.len()), Bias::Right);
+                        let start_ix = buffer.clip_offset(rng.random_range(0..=end_ix), Bias::Left);
                         ExcerptRange::new(start_ix..end_ix)
                     })
                     .collect::<Vec<_>>();
@@ -3708,7 +3709,7 @@ impl MultiBuffer {
                 let excerpt_id = self.push_excerpts(buffer_handle.clone(), ranges, cx);
                 log::info!("Inserted with ids: {:?}", excerpt_id);
             } else {
-                let remove_count = rng.gen_range(1..=excerpt_ids.len());
+                let remove_count = rng.random_range(1..=excerpt_ids.len());
                 let mut excerpts_to_remove = excerpt_ids
                     .choose_multiple(rng, remove_count)
                     .cloned()
@@ -3730,7 +3731,7 @@ impl MultiBuffer {
     ) {
         use rand::prelude::*;
 
-        if rng.gen_bool(0.7) || self.singleton {
+        if rng.random_bool(0.7) || self.singleton {
             let buffer = self
                 .buffers
                 .borrow()
@@ -3740,7 +3741,7 @@ impl MultiBuffer {
 
             if let Some(buffer) = buffer {
                 buffer.update(cx, |buffer, cx| {
-                    if rng.r#gen() {
+                    if rng.random() {
                         buffer.randomly_edit(rng, mutation_count, cx);
                     } else {
                         buffer.randomly_undo_redo(rng, cx);
@@ -6094,6 +6095,28 @@ impl MultiBufferSnapshot {
         Some((node, range))
     }
 
+    pub fn syntax_next_sibling<T: ToOffset>(
+        &self,
+        range: Range<T>,
+    ) -> Option<tree_sitter::Node<'_>> {
+        let range = range.start.to_offset(self)..range.end.to_offset(self);
+        let mut excerpt = self.excerpt_containing(range.clone())?;
+        excerpt
+            .buffer()
+            .syntax_next_sibling(excerpt.map_range_to_buffer(range))
+    }
+
+    pub fn syntax_prev_sibling<T: ToOffset>(
+        &self,
+        range: Range<T>,
+    ) -> Option<tree_sitter::Node<'_>> {
+        let range = range.start.to_offset(self)..range.end.to_offset(self);
+        let mut excerpt = self.excerpt_containing(range.clone())?;
+        excerpt
+            .buffer()
+            .syntax_prev_sibling(excerpt.map_range_to_buffer(range))
+    }
+
     pub fn outline(&self, theme: Option<&SyntaxTheme>) -> Option<Outline<Anchor>> {
         let (excerpt_id, _, buffer) = self.as_singleton()?;
         let outline = buffer.outline(theme)?;
@@ -6388,8 +6411,8 @@ impl MultiBufferSnapshot {
 #[cfg(any(test, feature = "test-support"))]
 impl MultiBufferSnapshot {
     pub fn random_byte_range(&self, start_offset: usize, rng: &mut impl rand::Rng) -> Range<usize> {
-        let end = self.clip_offset(rng.gen_range(start_offset..=self.len()), Bias::Right);
-        let start = self.clip_offset(rng.gen_range(start_offset..=end), Bias::Right);
+        let end = self.clip_offset(rng.random_range(start_offset..=self.len()), Bias::Right);
+        let start = self.clip_offset(rng.random_range(start_offset..=end), Bias::Right);
         start..end
     }
 
diff --git a/crates/multi_buffer/src/multi_buffer_tests.rs b/crates/multi_buffer/src/multi_buffer_tests.rs
index 61b4b0520f23ed50b3b36374710b52c78c37080f..efc622b0172a13ae9a6ad3bf366904706a36580f 100644
--- a/crates/multi_buffer/src/multi_buffer_tests.rs
+++ b/crates/multi_buffer/src/multi_buffer_tests.rs
@@ -2491,12 +2491,12 @@ async fn test_random_set_ranges(cx: &mut TestAppContext, mut rng: StdRng) {
 
     for _ in 0..operations {
         let snapshot = buf.update(cx, |buf, _| buf.snapshot());
-        let num_ranges = rng.gen_range(0..=10);
+        let num_ranges = rng.random_range(0..=10);
         let max_row = snapshot.max_point().row;
         let mut ranges = (0..num_ranges)
             .map(|_| {
-                let start = rng.gen_range(0..max_row);
-                let end = rng.gen_range(start + 1..max_row + 1);
+                let start = rng.random_range(0..max_row);
+                let end = rng.random_range(start + 1..max_row + 1);
                 Point::row_range(start..end)
             })
             .collect::<Vec<_>>();
@@ -2562,11 +2562,11 @@ async fn test_random_multibuffer(cx: &mut TestAppContext, mut rng: StdRng) {
     let mut needs_diff_calculation = false;
 
     for _ in 0..operations {
-        match rng.gen_range(0..100) {
+        match rng.random_range(0..100) {
             0..=14 if !buffers.is_empty() => {
                 let buffer = buffers.choose(&mut rng).unwrap();
                 buffer.update(cx, |buf, cx| {
-                    let edit_count = rng.gen_range(1..5);
+                    let edit_count = rng.random_range(1..5);
                     buf.randomly_edit(&mut rng, edit_count, cx);
                     log::info!("buffer text:\n{}", buf.text());
                     needs_diff_calculation = true;
@@ -2577,11 +2577,11 @@ async fn test_random_multibuffer(cx: &mut TestAppContext, mut rng: StdRng) {
                 multibuffer.update(cx, |multibuffer, cx| {
                     let ids = multibuffer.excerpt_ids();
                     let mut excerpts = HashSet::default();
-                    for _ in 0..rng.gen_range(0..ids.len()) {
+                    for _ in 0..rng.random_range(0..ids.len()) {
                         excerpts.extend(ids.choose(&mut rng).copied());
                     }
 
-                    let line_count = rng.gen_range(0..5);
+                    let line_count = rng.random_range(0..5);
 
                     let excerpt_ixs = excerpts
                         .iter()
@@ -2600,7 +2600,7 @@ async fn test_random_multibuffer(cx: &mut TestAppContext, mut rng: StdRng) {
             }
             20..=29 if !reference.excerpts.is_empty() => {
                 let mut ids_to_remove = vec![];
-                for _ in 0..rng.gen_range(1..=3) {
+                for _ in 0..rng.random_range(1..=3) {
                     let Some(excerpt) = reference.excerpts.choose(&mut rng) else {
                         break;
                     };
@@ -2620,8 +2620,12 @@ async fn test_random_multibuffer(cx: &mut TestAppContext, mut rng: StdRng) {
                 let multibuffer =
                     multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
                 let offset =
-                    multibuffer.clip_offset(rng.gen_range(0..=multibuffer.len()), Bias::Left);
-                let bias = if rng.r#gen() { Bias::Left } else { Bias::Right };
+                    multibuffer.clip_offset(rng.random_range(0..=multibuffer.len()), Bias::Left);
+                let bias = if rng.random() {
+                    Bias::Left
+                } else {
+                    Bias::Right
+                };
                 log::info!("Creating anchor at {} with bias {:?}", offset, bias);
                 anchors.push(multibuffer.anchor_at(offset, bias));
                 anchors.sort_by(|a, b| a.cmp(b, &multibuffer));
@@ -2654,7 +2658,7 @@ async fn test_random_multibuffer(cx: &mut TestAppContext, mut rng: StdRng) {
             45..=55 if !reference.excerpts.is_empty() => {
                 multibuffer.update(cx, |multibuffer, cx| {
                     let snapshot = multibuffer.snapshot(cx);
-                    let excerpt_ix = rng.gen_range(0..reference.excerpts.len());
+                    let excerpt_ix = rng.random_range(0..reference.excerpts.len());
                     let excerpt = &reference.excerpts[excerpt_ix];
                     let start = excerpt.range.start;
                     let end = excerpt.range.end;
@@ -2691,7 +2695,7 @@ async fn test_random_multibuffer(cx: &mut TestAppContext, mut rng: StdRng) {
                 });
             }
             _ => {
-                let buffer_handle = if buffers.is_empty() || rng.gen_bool(0.4) {
+                let buffer_handle = if buffers.is_empty() || rng.random_bool(0.4) {
                     let mut base_text = util::RandomCharIter::new(&mut rng)
                         .take(256)
                         .collect::<String>();
@@ -2708,7 +2712,7 @@ async fn test_random_multibuffer(cx: &mut TestAppContext, mut rng: StdRng) {
                     buffers.choose(&mut rng).unwrap()
                 };
 
-                let prev_excerpt_ix = rng.gen_range(0..=reference.excerpts.len());
+                let prev_excerpt_ix = rng.random_range(0..=reference.excerpts.len());
                 let prev_excerpt_id = reference
                     .excerpts
                     .get(prev_excerpt_ix)
@@ -2716,8 +2720,8 @@ async fn test_random_multibuffer(cx: &mut TestAppContext, mut rng: StdRng) {
                 let excerpt_ix = (prev_excerpt_ix + 1).min(reference.excerpts.len());
 
                 let (range, anchor_range) = buffer_handle.read_with(cx, |buffer, _| {
-                    let end_row = rng.gen_range(0..=buffer.max_point().row);
-                    let start_row = rng.gen_range(0..=end_row);
+                    let end_row = rng.random_range(0..=buffer.max_point().row);
+                    let start_row = rng.random_range(0..=end_row);
                     let end_ix = buffer.point_to_offset(Point::new(end_row, 0));
                     let start_ix = buffer.point_to_offset(Point::new(start_row, 0));
                     let anchor_range = buffer.anchor_before(start_ix)..buffer.anchor_after(end_ix);
@@ -2766,7 +2770,7 @@ async fn test_random_multibuffer(cx: &mut TestAppContext, mut rng: StdRng) {
             }
         }
 
-        if rng.gen_bool(0.3) {
+        if rng.random_bool(0.3) {
             multibuffer.update(cx, |multibuffer, cx| {
                 old_versions.push((multibuffer.snapshot(cx), multibuffer.subscribe()));
             })
@@ -2815,7 +2819,7 @@ async fn test_random_multibuffer(cx: &mut TestAppContext, mut rng: StdRng) {
         pretty_assertions::assert_eq!(actual_row_infos, expected_row_infos);
 
         for _ in 0..5 {
-            let start_row = rng.gen_range(0..=expected_row_infos.len());
+            let start_row = rng.random_range(0..=expected_row_infos.len());
             assert_eq!(
                 snapshot
                     .row_infos(MultiBufferRow(start_row as u32))
@@ -2872,8 +2876,8 @@ async fn test_random_multibuffer(cx: &mut TestAppContext, mut rng: StdRng) {
 
         let text_rope = Rope::from(expected_text.as_str());
         for _ in 0..10 {
-            let end_ix = text_rope.clip_offset(rng.gen_range(0..=text_rope.len()), Bias::Right);
-            let start_ix = text_rope.clip_offset(rng.gen_range(0..=end_ix), Bias::Left);
+            let end_ix = text_rope.clip_offset(rng.random_range(0..=text_rope.len()), Bias::Right);
+            let start_ix = text_rope.clip_offset(rng.random_range(0..=end_ix), Bias::Left);
 
             let text_for_range = snapshot
                 .text_for_range(start_ix..end_ix)
@@ -2908,7 +2912,7 @@ async fn test_random_multibuffer(cx: &mut TestAppContext, mut rng: StdRng) {
         }
 
         for _ in 0..10 {
-            let end_ix = text_rope.clip_offset(rng.gen_range(0..=text_rope.len()), Bias::Right);
+            let end_ix = text_rope.clip_offset(rng.random_range(0..=text_rope.len()), Bias::Right);
             assert_eq!(
                 snapshot.reversed_chars_at(end_ix).collect::<String>(),
                 expected_text[..end_ix].chars().rev().collect::<String>(),
@@ -2916,8 +2920,8 @@ async fn test_random_multibuffer(cx: &mut TestAppContext, mut rng: StdRng) {
         }
 
         for _ in 0..10 {
-            let end_ix = rng.gen_range(0..=text_rope.len());
-            let start_ix = rng.gen_range(0..=end_ix);
+            let end_ix = rng.random_range(0..=text_rope.len());
+            let start_ix = rng.random_range(0..=end_ix);
             assert_eq!(
                 snapshot
                     .bytes_in_range(start_ix..end_ix)
diff --git a/crates/notifications/Cargo.toml b/crates/notifications/Cargo.toml
index baf5444ef4903dd1d0efc64e7553abe3ed414720..39acfe2b384c8a2264c5c2dac91024edad89d33a 100644
--- a/crates/notifications/Cargo.toml
+++ b/crates/notifications/Cargo.toml
@@ -24,7 +24,6 @@ test-support = [
 anyhow.workspace = true
 channel.workspace = true
 client.workspace = true
-collections.workspace = true
 component.workspace = true
 db.workspace = true
 gpui.workspace = true
diff --git a/crates/notifications/src/notification_store.rs b/crates/notifications/src/notification_store.rs
index af2601bd181089a4952529ab4f315aa148e25121..7db17da9ff92bce492cc8414be8db28c219d61e7 100644
--- a/crates/notifications/src/notification_store.rs
+++ b/crates/notifications/src/notification_store.rs
@@ -1,7 +1,6 @@
 use anyhow::{Context as _, Result};
-use channel::{ChannelMessage, ChannelMessageId, ChannelStore};
+use channel::ChannelStore;
 use client::{ChannelId, Client, UserStore};
-use collections::HashMap;
 use db::smol::stream::StreamExt;
 use gpui::{App, AppContext as _, AsyncApp, Context, Entity, EventEmitter, Global, Task};
 use rpc::{Notification, TypedEnvelope, proto};
@@ -22,7 +21,6 @@ impl Global for GlobalNotificationStore {}
 pub struct NotificationStore {
     client: Arc<Client>,
     user_store: Entity<UserStore>,
-    channel_messages: HashMap<u64, ChannelMessage>,
     channel_store: Entity<ChannelStore>,
     notifications: SumTree<NotificationEntry>,
     loaded_all_notifications: bool,
@@ -100,12 +98,10 @@ impl NotificationStore {
             channel_store: ChannelStore::global(cx),
             notifications: Default::default(),
             loaded_all_notifications: false,
-            channel_messages: Default::default(),
             _watch_connection_status: watch_connection_status,
             _subscriptions: vec![
                 client.add_message_handler(cx.weak_entity(), Self::handle_new_notification),
                 client.add_message_handler(cx.weak_entity(), Self::handle_delete_notification),
-                client.add_message_handler(cx.weak_entity(), Self::handle_update_notification),
             ],
             user_store,
             client,
@@ -120,10 +116,6 @@ impl NotificationStore {
         self.notifications.summary().unread_count
     }
 
-    pub fn channel_message_for_id(&self, id: u64) -> Option<&ChannelMessage> {
-        self.channel_messages.get(&id)
-    }
-
     // Get the nth newest notification.
     pub fn notification_at(&self, ix: usize) -> Option<&NotificationEntry> {
         let count = self.notifications.summary().count;
@@ -185,7 +177,6 @@ impl NotificationStore {
 
     fn handle_connect(&mut self, cx: &mut Context<Self>) -> Option<Task<Result<()>>> {
         self.notifications = Default::default();
-        self.channel_messages = Default::default();
         cx.notify();
         self.load_more_notifications(true, cx)
     }
@@ -223,35 +214,6 @@ impl NotificationStore {
         })?
     }
 
-    async fn handle_update_notification(
-        this: Entity<Self>,
-        envelope: TypedEnvelope<proto::UpdateNotification>,
-        mut cx: AsyncApp,
-    ) -> Result<()> {
-        this.update(&mut cx, |this, cx| {
-            if let Some(notification) = envelope.payload.notification
-                && let Some(rpc::Notification::ChannelMessageMention { message_id, .. }) =
-                    Notification::from_proto(&notification)
-            {
-                let fetch_message_task = this.channel_store.update(cx, |this, cx| {
-                    this.fetch_channel_messages(vec![message_id], cx)
-                });
-
-                cx.spawn(async move |this, cx| {
-                    let messages = fetch_message_task.await?;
-                    this.update(cx, move |this, cx| {
-                        for message in messages {
-                            this.channel_messages.insert(message_id, message);
-                        }
-                        cx.notify();
-                    })
-                })
-                .detach_and_log_err(cx)
-            }
-            Ok(())
-        })?
-    }
-
     async fn add_notifications(
         this: Entity<Self>,
         notifications: Vec<proto::Notification>,
@@ -259,7 +221,6 @@ impl NotificationStore {
         cx: &mut AsyncApp,
     ) -> Result<()> {
         let mut user_ids = Vec::new();
-        let mut message_ids = Vec::new();
 
         let notifications = notifications
             .into_iter()
@@ -293,29 +254,14 @@ impl NotificationStore {
                 } => {
                     user_ids.push(contact_id);
                 }
-                Notification::ChannelMessageMention {
-                    sender_id,
-                    message_id,
-                    ..
-                } => {
-                    user_ids.push(sender_id);
-                    message_ids.push(message_id);
-                }
             }
         }
 
-        let (user_store, channel_store) = this.read_with(cx, |this, _| {
-            (this.user_store.clone(), this.channel_store.clone())
-        })?;
+        let user_store = this.read_with(cx, |this, _| this.user_store.clone())?;
 
         user_store
             .update(cx, |store, cx| store.get_users(user_ids, cx))?
             .await?;
-        let messages = channel_store
-            .update(cx, |store, cx| {
-                store.fetch_channel_messages(message_ids, cx)
-            })?
-            .await?;
         this.update(cx, |this, cx| {
             if options.clear_old {
                 cx.emit(NotificationEvent::NotificationsUpdated {
@@ -323,7 +269,6 @@ impl NotificationStore {
                     new_count: 0,
                 });
                 this.notifications = SumTree::default();
-                this.channel_messages.clear();
                 this.loaded_all_notifications = false;
             }
 
@@ -331,15 +276,6 @@ impl NotificationStore {
                 this.loaded_all_notifications = true;
             }
 
-            this.channel_messages
-                .extend(messages.into_iter().filter_map(|message| {
-                    if let ChannelMessageId::Saved(id) = message.id {
-                        Some((id, message))
-                    } else {
-                        None
-                    }
-                }));
-
             this.splice_notifications(
                 notifications
                     .into_iter()
diff --git a/crates/ollama/src/ollama.rs b/crates/ollama/src/ollama.rs
index 64cd1cc0cbc06607ee9b3b72ee81cbeb9489c344..3c935d2152556393829f648abe31a717b239ce76 100644
--- a/crates/ollama/src/ollama.rs
+++ b/crates/ollama/src/ollama.rs
@@ -117,6 +117,10 @@ pub enum ChatMessage {
     System {
         content: String,
     },
+    Tool {
+        tool_name: String,
+        content: String,
+    },
 }
 
 #[derive(Serialize, Deserialize, Debug)]
diff --git a/crates/onboarding/src/ai_setup_page.rs b/crates/onboarding/src/ai_setup_page.rs
index 54c49bc72a49309002421c4f8ac3544c86e4dc69..3631ad00dfb8662d5d4142a4cbd11186c1b1b137 100644
--- a/crates/onboarding/src/ai_setup_page.rs
+++ b/crates/onboarding/src/ai_setup_page.rs
@@ -264,13 +264,9 @@ pub(crate) fn render_ai_setup_page(
                     );
 
                     let fs = <dyn Fs>::global(cx);
-                    update_settings_file::<DisableAiSettings>(
-                        fs,
-                        cx,
-                        move |ai_settings: &mut Option<bool>, _| {
-                            *ai_settings = Some(enabled);
-                        },
-                    );
+                    update_settings_file::<DisableAiSettings>(fs, cx, move |ai_settings, _| {
+                        ai_settings.disable_ai = Some(enabled);
+                    });
                 },
             )
             .tab_index({
diff --git a/crates/onboarding/src/basics_page.rs b/crates/onboarding/src/basics_page.rs
index 59ec437dcf8d11209e9c73020f1b51e40aa56cce..aef9dcca86ce49a70f1a508c0a43614737a653c7 100644
--- a/crates/onboarding/src/basics_page.rs
+++ b/crates/onboarding/src/basics_page.rs
@@ -388,7 +388,7 @@ fn render_vim_mode_switch(tab_index: &mut isize, cx: &mut App) -> impl IntoEleme
                     }
                 };
                 update_settings_file::<VimModeSetting>(fs.clone(), cx, move |setting, _| {
-                    *setting = Some(vim_mode);
+                    setting.vim_mode = Some(vim_mode);
                 });
 
                 telemetry::event!(
diff --git a/crates/onboarding/src/editing_page.rs b/crates/onboarding/src/editing_page.rs
index 47dfd84894bf0ca5e7fd4a5a9ad0785d80b07ac5..297016abd4a1499feb6f637d028056ca0b412d31 100644
--- a/crates/onboarding/src/editing_page.rs
+++ b/crates/onboarding/src/editing_page.rs
@@ -449,28 +449,28 @@ impl FontPickerDelegate {
     ) -> Self {
         let font_family_cache = FontFamilyCache::global(cx);
 
-        let fonts: Vec<SharedString> = font_family_cache
-            .list_font_families(cx)
-            .into_iter()
-            .collect();
-
+        let fonts = font_family_cache
+            .try_list_font_families()
+            .unwrap_or_else(|| vec![current_font.clone()]);
         let selected_index = fonts
             .iter()
             .position(|font| *font == current_font)
             .unwrap_or(0);
 
+        let filtered_fonts = fonts
+            .iter()
+            .enumerate()
+            .map(|(index, font)| StringMatch {
+                candidate_id: index,
+                string: font.to_string(),
+                positions: Vec::new(),
+                score: 0.0,
+            })
+            .collect();
+
         Self {
-            fonts: fonts.clone(),
-            filtered_fonts: fonts
-                .iter()
-                .enumerate()
-                .map(|(index, font)| StringMatch {
-                    candidate_id: index,
-                    string: font.to_string(),
-                    positions: Vec::new(),
-                    score: 0.0,
-                })
-                .collect(),
+            fonts,
+            filtered_fonts,
             selected_index,
             current_font,
             on_font_changed: Arc::new(on_font_changed),
diff --git a/crates/onboarding/src/onboarding.rs b/crates/onboarding/src/onboarding.rs
index 7f1bb81d4d7486ea85e23dedcb763e238d53b2f3..9dcf27c7cbebf6621bbeb558619944c768e63fb6 100644
--- a/crates/onboarding/src/onboarding.rs
+++ b/crates/onboarding/src/onboarding.rs
@@ -242,12 +242,25 @@ struct Onboarding {
 
 impl Onboarding {
     fn new(workspace: &Workspace, cx: &mut App) -> Entity<Self> {
-        cx.new(|cx| Self {
-            workspace: workspace.weak_handle(),
-            focus_handle: cx.focus_handle(),
-            selected_page: SelectedPage::Basics,
-            user_store: workspace.user_store().clone(),
-            _settings_subscription: cx.observe_global::<SettingsStore>(move |_, cx| cx.notify()),
+        let font_family_cache = theme::FontFamilyCache::global(cx);
+
+        cx.new(|cx| {
+            cx.spawn(async move |this, cx| {
+                font_family_cache.prefetch(cx).await;
+                this.update(cx, |_, cx| {
+                    cx.notify();
+                })
+            })
+            .detach();
+
+            Self {
+                workspace: workspace.weak_handle(),
+                focus_handle: cx.focus_handle(),
+                selected_page: SelectedPage::Basics,
+                user_store: workspace.user_store().clone(),
+                _settings_subscription: cx
+                    .observe_global::<SettingsStore>(move |_, cx| cx.notify()),
+            }
         })
     }
 
diff --git a/crates/open_ai/src/open_ai.rs b/crates/open_ai/src/open_ai.rs
index 279245c0b7d5a545a5d5c7725347f0b5153a4deb..fda0544be1748f3bf958cd159bc55edccdbb5c14 100644
--- a/crates/open_ai/src/open_ai.rs
+++ b/crates/open_ai/src/open_ai.rs
@@ -473,7 +473,7 @@ pub async fn stream_completion(
             .filter_map(|line| async move {
                 match line {
                     Ok(line) => {
-                        let line = line.strip_prefix("data: ")?;
+                        let line = line.strip_prefix("data: ").or_else(|| line.strip_prefix("data:"))?;
                         if line == "[DONE]" {
                             None
                         } else {
diff --git a/crates/open_router/src/open_router.rs b/crates/open_router/src/open_router.rs
index dfaa49746d093810924f744cd1aeb3e8747ddb00..cbc6c243d87c8f9ea3d0186dbecb8f0ac2e10a90 100644
--- a/crates/open_router/src/open_router.rs
+++ b/crates/open_router/src/open_router.rs
@@ -529,12 +529,16 @@ pub async fn stream_completion(
 pub async fn list_models(
     client: &dyn HttpClient,
     api_url: &str,
+    api_key: &str,
 ) -> Result<Vec<Model>, OpenRouterError> {
-    let uri = format!("{api_url}/models");
+    let uri = format!("{api_url}/models/user");
     let request_builder = HttpRequest::builder()
         .method(Method::GET)
         .uri(uri)
-        .header("Accept", "application/json");
+        .header("Accept", "application/json")
+        .header("Authorization", format!("Bearer {}", api_key))
+        .header("HTTP-Referer", "https://zed.dev")
+        .header("X-Title", "Zed Editor");
 
     let request = request_builder
         .body(AsyncBody::default())
diff --git a/crates/outline_panel/src/outline_panel_settings.rs b/crates/outline_panel/src/outline_panel_settings.rs
index 48c6621e3509c1eda69a6a5e92602ba2ab12a484..dc123f2ba5fb38dd80b72aee8fc6ad6a000be23d 100644
--- a/crates/outline_panel/src/outline_panel_settings.rs
+++ b/crates/outline_panel/src/outline_panel_settings.rs
@@ -2,7 +2,7 @@ use editor::ShowScrollbar;
 use gpui::Pixels;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, Copy, PartialEq)]
 #[serde(rename_all = "snake_case")]
@@ -61,7 +61,8 @@ pub struct IndentGuidesSettingsContent {
     pub show: Option<ShowIndentGuides>,
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi, SettingsKey)]
+#[settings_key(key = "outline_panel")]
 pub struct OutlinePanelSettingsContent {
     /// Whether to show the outline panel button in the status bar.
     ///
@@ -116,8 +117,6 @@ pub struct OutlinePanelSettingsContent {
 }
 
 impl Settings for OutlinePanelSettings {
-    const KEY: Option<&'static str> = Some("outline_panel");
-
     type FileContent = OutlinePanelSettingsContent;
 
     fn load(
diff --git a/crates/project/Cargo.toml b/crates/project/Cargo.toml
index 57d6d6ca283af0fd51ed10622f55edc9fb086e7e..3d46a44770ec2504991899e98c1504116611c20b 100644
--- a/crates/project/Cargo.toml
+++ b/crates/project/Cargo.toml
@@ -67,6 +67,7 @@ regex.workspace = true
 remote.workspace = true
 rpc.workspace = true
 schemars.workspace = true
+semver.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 settings.workspace = true
@@ -85,6 +86,7 @@ text.workspace = true
 toml.workspace = true
 url.workspace = true
 util.workspace = true
+watch.workspace = true
 which.workspace = true
 worktree.workspace = true
 zlog.workspace = true
diff --git a/crates/project/src/agent_server_store.rs b/crates/project/src/agent_server_store.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5f9342c8933d43da9bab6d63bc455ea0496d4712
--- /dev/null
+++ b/crates/project/src/agent_server_store.rs
@@ -0,0 +1,1091 @@
+use std::{
+    any::Any,
+    borrow::Borrow,
+    path::{Path, PathBuf},
+    str::FromStr as _,
+    sync::Arc,
+    time::Duration,
+};
+
+use anyhow::{Context as _, Result, bail};
+use collections::HashMap;
+use fs::{Fs, RemoveOptions, RenameOptions};
+use futures::StreamExt as _;
+use gpui::{
+    App, AppContext as _, AsyncApp, Context, Entity, EventEmitter, SharedString, Subscription, Task,
+};
+use node_runtime::NodeRuntime;
+use remote::RemoteClient;
+use rpc::{
+    AnyProtoClient, TypedEnvelope,
+    proto::{self, ToProto},
+};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use settings::{SettingsKey, SettingsSources, SettingsStore, SettingsUi};
+use util::{ResultExt as _, debug_panic};
+
+use crate::ProjectEnvironment;
+
+#[derive(Deserialize, Serialize, Clone, PartialEq, Eq, JsonSchema)]
+pub struct AgentServerCommand {
+    #[serde(rename = "command")]
+    pub path: PathBuf,
+    #[serde(default)]
+    pub args: Vec<String>,
+    pub env: Option<HashMap<String, String>>,
+}
+
+impl std::fmt::Debug for AgentServerCommand {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let filtered_env = self.env.as_ref().map(|env| {
+            env.iter()
+                .map(|(k, v)| {
+                    (
+                        k,
+                        if util::redact::should_redact(k) {
+                            "[REDACTED]"
+                        } else {
+                            v
+                        },
+                    )
+                })
+                .collect::<Vec<_>>()
+        });
+
+        f.debug_struct("AgentServerCommand")
+            .field("path", &self.path)
+            .field("args", &self.args)
+            .field("env", &filtered_env)
+            .finish()
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct ExternalAgentServerName(pub SharedString);
+
+impl std::fmt::Display for ExternalAgentServerName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl From<&'static str> for ExternalAgentServerName {
+    fn from(value: &'static str) -> Self {
+        ExternalAgentServerName(value.into())
+    }
+}
+
+impl From<ExternalAgentServerName> for SharedString {
+    fn from(value: ExternalAgentServerName) -> Self {
+        value.0
+    }
+}
+
+impl Borrow<str> for ExternalAgentServerName {
+    fn borrow(&self) -> &str {
+        &self.0
+    }
+}
+
+pub trait ExternalAgentServer {
+    fn get_command(
+        &mut self,
+        root_dir: Option<&str>,
+        extra_env: HashMap<String, String>,
+        status_tx: Option<watch::Sender<SharedString>>,
+        new_version_available_tx: Option<watch::Sender<Option<String>>>,
+        cx: &mut AsyncApp,
+    ) -> Task<Result<(AgentServerCommand, String, Option<task::SpawnInTerminal>)>>;
+
+    fn as_any_mut(&mut self) -> &mut dyn Any;
+}
+
+impl dyn ExternalAgentServer {
+    fn downcast_mut<T: ExternalAgentServer + 'static>(&mut self) -> Option<&mut T> {
+        self.as_any_mut().downcast_mut()
+    }
+}
+
+enum AgentServerStoreState {
+    Local {
+        node_runtime: NodeRuntime,
+        fs: Arc<dyn Fs>,
+        project_environment: Entity<ProjectEnvironment>,
+        downstream_client: Option<(u64, AnyProtoClient)>,
+        settings: Option<AllAgentServersSettings>,
+        _subscriptions: [Subscription; 1],
+    },
+    Remote {
+        project_id: u64,
+        upstream_client: Entity<RemoteClient>,
+    },
+    Collab,
+}
+
+pub struct AgentServerStore {
+    state: AgentServerStoreState,
+    external_agents: HashMap<ExternalAgentServerName, Box<dyn ExternalAgentServer>>,
+}
+
+pub struct AgentServersUpdated;
+
+impl EventEmitter<AgentServersUpdated> for AgentServerStore {}
+
+impl AgentServerStore {
+    pub fn init_remote(session: &AnyProtoClient) {
+        session.add_entity_message_handler(Self::handle_external_agents_updated);
+        session.add_entity_message_handler(Self::handle_loading_status_updated);
+        session.add_entity_message_handler(Self::handle_new_version_available);
+    }
+
+    pub fn init_headless(session: &AnyProtoClient) {
+        session.add_entity_request_handler(Self::handle_get_agent_server_command);
+    }
+
+    fn agent_servers_settings_changed(&mut self, cx: &mut Context<Self>) {
+        let AgentServerStoreState::Local {
+            node_runtime,
+            fs,
+            project_environment,
+            downstream_client,
+            settings: old_settings,
+            ..
+        } = &mut self.state
+        else {
+            debug_panic!(
+                "should not be subscribed to agent server settings changes in non-local project"
+            );
+            return;
+        };
+
+        let new_settings = cx
+            .global::<SettingsStore>()
+            .get::<AllAgentServersSettings>(None)
+            .clone();
+        if Some(&new_settings) == old_settings.as_ref() {
+            return;
+        }
+
+        self.external_agents.clear();
+        self.external_agents.insert(
+            GEMINI_NAME.into(),
+            Box::new(LocalGemini {
+                fs: fs.clone(),
+                node_runtime: node_runtime.clone(),
+                project_environment: project_environment.clone(),
+                custom_command: new_settings
+                    .gemini
+                    .clone()
+                    .and_then(|settings| settings.custom_command()),
+                ignore_system_version: new_settings
+                    .gemini
+                    .as_ref()
+                    .and_then(|settings| settings.ignore_system_version)
+                    .unwrap_or(true),
+            }),
+        );
+        self.external_agents.insert(
+            CLAUDE_CODE_NAME.into(),
+            Box::new(LocalClaudeCode {
+                fs: fs.clone(),
+                node_runtime: node_runtime.clone(),
+                project_environment: project_environment.clone(),
+                custom_command: new_settings.claude.clone().map(|settings| settings.command),
+            }),
+        );
+        self.external_agents
+            .extend(new_settings.custom.iter().map(|(name, settings)| {
+                (
+                    ExternalAgentServerName(name.clone()),
+                    Box::new(LocalCustomAgent {
+                        command: settings.command.clone(),
+                        project_environment: project_environment.clone(),
+                    }) as Box<dyn ExternalAgentServer>,
+                )
+            }));
+
+        *old_settings = Some(new_settings.clone());
+
+        if let Some((project_id, downstream_client)) = downstream_client {
+            downstream_client
+                .send(proto::ExternalAgentsUpdated {
+                    project_id: *project_id,
+                    names: self
+                        .external_agents
+                        .keys()
+                        .map(|name| name.to_string())
+                        .collect(),
+                })
+                .log_err();
+        }
+        cx.emit(AgentServersUpdated);
+    }
+
+    pub fn local(
+        node_runtime: NodeRuntime,
+        fs: Arc<dyn Fs>,
+        project_environment: Entity<ProjectEnvironment>,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let subscription = cx.observe_global::<SettingsStore>(|this, cx| {
+            this.agent_servers_settings_changed(cx);
+        });
+        let this = Self {
+            state: AgentServerStoreState::Local {
+                node_runtime,
+                fs,
+                project_environment,
+                downstream_client: None,
+                settings: None,
+                _subscriptions: [subscription],
+            },
+            external_agents: Default::default(),
+        };
+        cx.spawn(async move |this, cx| {
+            cx.background_executor().timer(Duration::from_secs(1)).await;
+            this.update(cx, |this, cx| {
+                this.agent_servers_settings_changed(cx);
+            })
+            .ok();
+        })
+        .detach();
+        this
+    }
+
+    pub(crate) fn remote(
+        project_id: u64,
+        upstream_client: Entity<RemoteClient>,
+        _cx: &mut Context<Self>,
+    ) -> Self {
+        // Set up the builtin agents here so they're immediately available in
+        // remote projects--we know that the HeadlessProject on the other end
+        // will have them.
+        let external_agents = [
+            (
+                GEMINI_NAME.into(),
+                Box::new(RemoteExternalAgentServer {
+                    project_id,
+                    upstream_client: upstream_client.clone(),
+                    name: GEMINI_NAME.into(),
+                    status_tx: None,
+                    new_version_available_tx: None,
+                }) as Box<dyn ExternalAgentServer>,
+            ),
+            (
+                CLAUDE_CODE_NAME.into(),
+                Box::new(RemoteExternalAgentServer {
+                    project_id,
+                    upstream_client: upstream_client.clone(),
+                    name: CLAUDE_CODE_NAME.into(),
+                    status_tx: None,
+                    new_version_available_tx: None,
+                }) as Box<dyn ExternalAgentServer>,
+            ),
+        ]
+        .into_iter()
+        .collect();
+
+        Self {
+            state: AgentServerStoreState::Remote {
+                project_id,
+                upstream_client,
+            },
+            external_agents,
+        }
+    }
+
+    pub(crate) fn collab(_cx: &mut Context<Self>) -> Self {
+        Self {
+            state: AgentServerStoreState::Collab,
+            external_agents: Default::default(),
+        }
+    }
+
+    pub fn shared(&mut self, project_id: u64, client: AnyProtoClient) {
+        match &mut self.state {
+            AgentServerStoreState::Local {
+                downstream_client, ..
+            } => {
+                client
+                    .send(proto::ExternalAgentsUpdated {
+                        project_id,
+                        names: self
+                            .external_agents
+                            .keys()
+                            .map(|name| name.to_string())
+                            .collect(),
+                    })
+                    .log_err();
+                *downstream_client = Some((project_id, client));
+            }
+            AgentServerStoreState::Remote { .. } => {
+                debug_panic!(
+                    "external agents over collab not implemented, remote project should not be shared"
+                );
+            }
+            AgentServerStoreState::Collab => {
+                debug_panic!("external agents over collab not implemented, should not be shared");
+            }
+        }
+    }
+
+    pub fn get_external_agent(
+        &mut self,
+        name: &ExternalAgentServerName,
+    ) -> Option<&mut (dyn ExternalAgentServer + 'static)> {
+        self.external_agents
+            .get_mut(name)
+            .map(|agent| agent.as_mut())
+    }
+
+    pub fn external_agents(&self) -> impl Iterator<Item = &ExternalAgentServerName> {
+        self.external_agents.keys()
+    }
+
+    async fn handle_get_agent_server_command(
+        this: Entity<Self>,
+        envelope: TypedEnvelope<proto::GetAgentServerCommand>,
+        mut cx: AsyncApp,
+    ) -> Result<proto::AgentServerCommand> {
+        let (command, root_dir, login) = this
+            .update(&mut cx, |this, cx| {
+                let AgentServerStoreState::Local {
+                    downstream_client, ..
+                } = &this.state
+                else {
+                    debug_panic!("should not receive GetAgentServerCommand in a non-local project");
+                    bail!("unexpected GetAgentServerCommand request in a non-local project");
+                };
+                let agent = this
+                    .external_agents
+                    .get_mut(&*envelope.payload.name)
+                    .with_context(|| format!("agent `{}` not found", envelope.payload.name))?;
+                let (status_tx, new_version_available_tx) = downstream_client
+                    .clone()
+                    .map(|(project_id, downstream_client)| {
+                        let (status_tx, mut status_rx) = watch::channel(SharedString::from(""));
+                        let (new_version_available_tx, mut new_version_available_rx) =
+                            watch::channel(None);
+                        cx.spawn({
+                            let downstream_client = downstream_client.clone();
+                            let name = envelope.payload.name.clone();
+                            async move |_, _| {
+                                while let Some(status) = status_rx.recv().await.ok() {
+                                    downstream_client.send(
+                                        proto::ExternalAgentLoadingStatusUpdated {
+                                            project_id,
+                                            name: name.clone(),
+                                            status: status.to_string(),
+                                        },
+                                    )?;
+                                }
+                                anyhow::Ok(())
+                            }
+                        })
+                        .detach_and_log_err(cx);
+                        cx.spawn({
+                            let name = envelope.payload.name.clone();
+                            async move |_, _| {
+                                if let Some(version) =
+                                    new_version_available_rx.recv().await.ok().flatten()
+                                {
+                                    downstream_client.send(
+                                        proto::NewExternalAgentVersionAvailable {
+                                            project_id,
+                                            name: name.clone(),
+                                            version,
+                                        },
+                                    )?;
+                                }
+                                anyhow::Ok(())
+                            }
+                        })
+                        .detach_and_log_err(cx);
+                        (status_tx, new_version_available_tx)
+                    })
+                    .unzip();
+                anyhow::Ok(agent.get_command(
+                    envelope.payload.root_dir.as_deref(),
+                    HashMap::default(),
+                    status_tx,
+                    new_version_available_tx,
+                    &mut cx.to_async(),
+                ))
+            })??
+            .await?;
+        Ok(proto::AgentServerCommand {
+            path: command.path.to_string_lossy().to_string(),
+            args: command.args,
+            env: command
+                .env
+                .map(|env| env.into_iter().collect())
+                .unwrap_or_default(),
+            root_dir: root_dir,
+            login: login.map(|login| login.to_proto()),
+        })
+    }
+
+    async fn handle_external_agents_updated(
+        this: Entity<Self>,
+        envelope: TypedEnvelope<proto::ExternalAgentsUpdated>,
+        mut cx: AsyncApp,
+    ) -> Result<()> {
+        this.update(&mut cx, |this, cx| {
+            let AgentServerStoreState::Remote {
+                project_id,
+                upstream_client,
+            } = &this.state
+            else {
+                debug_panic!(
+                    "handle_external_agents_updated should not be called for a non-remote project"
+                );
+                bail!("unexpected ExternalAgentsUpdated message")
+            };
+
+            let mut status_txs = this
+                .external_agents
+                .iter_mut()
+                .filter_map(|(name, agent)| {
+                    Some((
+                        name.clone(),
+                        agent
+                            .downcast_mut::<RemoteExternalAgentServer>()?
+                            .status_tx
+                            .take(),
+                    ))
+                })
+                .collect::<HashMap<_, _>>();
+            let mut new_version_available_txs = this
+                .external_agents
+                .iter_mut()
+                .filter_map(|(name, agent)| {
+                    Some((
+                        name.clone(),
+                        agent
+                            .downcast_mut::<RemoteExternalAgentServer>()?
+                            .new_version_available_tx
+                            .take(),
+                    ))
+                })
+                .collect::<HashMap<_, _>>();
+
+            this.external_agents = envelope
+                .payload
+                .names
+                .into_iter()
+                .map(|name| {
+                    let agent = RemoteExternalAgentServer {
+                        project_id: *project_id,
+                        upstream_client: upstream_client.clone(),
+                        name: ExternalAgentServerName(name.clone().into()),
+                        status_tx: status_txs.remove(&*name).flatten(),
+                        new_version_available_tx: new_version_available_txs
+                            .remove(&*name)
+                            .flatten(),
+                    };
+                    (
+                        ExternalAgentServerName(name.into()),
+                        Box::new(agent) as Box<dyn ExternalAgentServer>,
+                    )
+                })
+                .collect();
+            cx.emit(AgentServersUpdated);
+            Ok(())
+        })?
+    }
+
+    async fn handle_loading_status_updated(
+        this: Entity<Self>,
+        envelope: TypedEnvelope<proto::ExternalAgentLoadingStatusUpdated>,
+        mut cx: AsyncApp,
+    ) -> Result<()> {
+        this.update(&mut cx, |this, _| {
+            if let Some(agent) = this.external_agents.get_mut(&*envelope.payload.name)
+                && let Some(agent) = agent.downcast_mut::<RemoteExternalAgentServer>()
+                && let Some(status_tx) = &mut agent.status_tx
+            {
+                status_tx.send(envelope.payload.status.into()).ok();
+            }
+        })
+    }
+
+    async fn handle_new_version_available(
+        this: Entity<Self>,
+        envelope: TypedEnvelope<proto::NewExternalAgentVersionAvailable>,
+        mut cx: AsyncApp,
+    ) -> Result<()> {
+        this.update(&mut cx, |this, _| {
+            if let Some(agent) = this.external_agents.get_mut(&*envelope.payload.name)
+                && let Some(agent) = agent.downcast_mut::<RemoteExternalAgentServer>()
+                && let Some(new_version_available_tx) = &mut agent.new_version_available_tx
+            {
+                new_version_available_tx
+                    .send(Some(envelope.payload.version))
+                    .ok();
+            }
+        })
+    }
+}
+
+fn get_or_npm_install_builtin_agent(
+    binary_name: SharedString,
+    package_name: SharedString,
+    entrypoint_path: PathBuf,
+    minimum_version: Option<semver::Version>,
+    status_tx: Option<watch::Sender<SharedString>>,
+    new_version_available: Option<watch::Sender<Option<String>>>,
+    fs: Arc<dyn Fs>,
+    node_runtime: NodeRuntime,
+    cx: &mut AsyncApp,
+) -> Task<std::result::Result<AgentServerCommand, anyhow::Error>> {
+    cx.spawn(async move |cx| {
+        let node_path = node_runtime.binary_path().await?;
+        let dir = paths::data_dir()
+            .join("external_agents")
+            .join(binary_name.as_str());
+        fs.create_dir(&dir).await?;
+
+        let mut stream = fs.read_dir(&dir).await?;
+        let mut versions = Vec::new();
+        let mut to_delete = Vec::new();
+        while let Some(entry) = stream.next().await {
+            let Ok(entry) = entry else { continue };
+            let Some(file_name) = entry.file_name() else {
+                continue;
+            };
+
+            if let Some(name) = file_name.to_str()
+                && let Some(version) = semver::Version::from_str(name).ok()
+                && fs
+                    .is_file(&dir.join(file_name).join(&entrypoint_path))
+                    .await
+            {
+                versions.push((version, file_name.to_owned()));
+            } else {
+                to_delete.push(file_name.to_owned())
+            }
+        }
+
+        versions.sort();
+        let newest_version = if let Some((version, file_name)) = versions.last().cloned()
+            && minimum_version.is_none_or(|minimum_version| version >= minimum_version)
+        {
+            versions.pop();
+            Some(file_name)
+        } else {
+            None
+        };
+        log::debug!("existing version of {package_name}: {newest_version:?}");
+        to_delete.extend(versions.into_iter().map(|(_, file_name)| file_name));
+
+        cx.background_spawn({
+            let fs = fs.clone();
+            let dir = dir.clone();
+            async move {
+                for file_name in to_delete {
+                    fs.remove_dir(
+                        &dir.join(file_name),
+                        RemoveOptions {
+                            recursive: true,
+                            ignore_if_not_exists: false,
+                        },
+                    )
+                    .await
+                    .ok();
+                }
+            }
+        })
+        .detach();
+
+        let version = if let Some(file_name) = newest_version {
+            cx.background_spawn({
+                let file_name = file_name.clone();
+                let dir = dir.clone();
+                let fs = fs.clone();
+                async move {
+                    let latest_version =
+                        node_runtime.npm_package_latest_version(&package_name).await;
+                    if let Ok(latest_version) = latest_version
+                        && &latest_version != &file_name.to_string_lossy()
+                    {
+                        download_latest_version(
+                            fs,
+                            dir.clone(),
+                            node_runtime,
+                            package_name.clone(),
+                        )
+                        .await
+                        .log_err();
+                        if let Some(mut new_version_available) = new_version_available {
+                            new_version_available.send(Some(latest_version)).ok();
+                        }
+                    }
+                }
+            })
+            .detach();
+            file_name
+        } else {
+            if let Some(mut status_tx) = status_tx {
+                status_tx.send("Installing…".into()).ok();
+            }
+            let dir = dir.clone();
+            cx.background_spawn(download_latest_version(
+                fs.clone(),
+                dir.clone(),
+                node_runtime,
+                package_name.clone(),
+            ))
+            .await?
+            .into()
+        };
+
+        let agent_server_path = dir.join(version).join(entrypoint_path);
+        let agent_server_path_exists = fs.is_file(&agent_server_path).await;
+        anyhow::ensure!(
+            agent_server_path_exists,
+            "Missing entrypoint path {} after installation",
+            agent_server_path.to_string_lossy()
+        );
+
+        anyhow::Ok(AgentServerCommand {
+            path: node_path,
+            args: vec![agent_server_path.to_string_lossy().to_string()],
+            env: None,
+        })
+    })
+}
+
+fn find_bin_in_path(
+    bin_name: SharedString,
+    root_dir: PathBuf,
+    env: HashMap<String, String>,
+    cx: &mut AsyncApp,
+) -> Task<Option<PathBuf>> {
+    cx.background_executor().spawn(async move {
+        let which_result = if cfg!(windows) {
+            which::which(bin_name.as_str())
+        } else {
+            let shell_path = env.get("PATH").cloned();
+            which::which_in(bin_name.as_str(), shell_path.as_ref(), &root_dir)
+        };
+
+        if let Err(which::Error::CannotFindBinaryPath) = which_result {
+            return None;
+        }
+
+        which_result.log_err()
+    })
+}
+
+async fn download_latest_version(
+    fs: Arc<dyn Fs>,
+    dir: PathBuf,
+    node_runtime: NodeRuntime,
+    package_name: SharedString,
+) -> Result<String> {
+    log::debug!("downloading latest version of {package_name}");
+
+    let tmp_dir = tempfile::tempdir_in(&dir)?;
+
+    node_runtime
+        .npm_install_packages(tmp_dir.path(), &[(&package_name, "latest")])
+        .await?;
+
+    let version = node_runtime
+        .npm_package_installed_version(tmp_dir.path(), &package_name)
+        .await?
+        .context("expected package to be installed")?;
+
+    fs.rename(
+        &tmp_dir.keep(),
+        &dir.join(&version),
+        RenameOptions {
+            ignore_if_exists: true,
+            overwrite: false,
+        },
+    )
+    .await?;
+
+    anyhow::Ok(version)
+}
+
+struct RemoteExternalAgentServer {
+    project_id: u64,
+    upstream_client: Entity<RemoteClient>,
+    name: ExternalAgentServerName,
+    status_tx: Option<watch::Sender<SharedString>>,
+    new_version_available_tx: Option<watch::Sender<Option<String>>>,
+}
+
+// new method: status_updated
+// does nothing in the all-local case
+// for RemoteExternalAgentServer, sends on the stored tx
+// etc.
+
+impl ExternalAgentServer for RemoteExternalAgentServer {
+    fn get_command(
+        &mut self,
+        root_dir: Option<&str>,
+        extra_env: HashMap<String, String>,
+        status_tx: Option<watch::Sender<SharedString>>,
+        new_version_available_tx: Option<watch::Sender<Option<String>>>,
+        cx: &mut AsyncApp,
+    ) -> Task<Result<(AgentServerCommand, String, Option<task::SpawnInTerminal>)>> {
+        let project_id = self.project_id;
+        let name = self.name.to_string();
+        let upstream_client = self.upstream_client.downgrade();
+        let root_dir = root_dir.map(|root_dir| root_dir.to_owned());
+        self.status_tx = status_tx;
+        self.new_version_available_tx = new_version_available_tx;
+        cx.spawn(async move |cx| {
+            let mut response = upstream_client
+                .update(cx, |upstream_client, _| {
+                    upstream_client
+                        .proto_client()
+                        .request(proto::GetAgentServerCommand {
+                            project_id,
+                            name,
+                            root_dir: root_dir.clone(),
+                        })
+                })?
+                .await?;
+            let root_dir = response.root_dir;
+            response.env.extend(extra_env);
+            let command = upstream_client.update(cx, |client, _| {
+                client.build_command(
+                    Some(response.path),
+                    &response.args,
+                    &response.env.into_iter().collect(),
+                    Some(root_dir.clone()),
+                    None,
+                )
+            })??;
+            Ok((
+                AgentServerCommand {
+                    path: command.program.into(),
+                    args: command.args,
+                    env: Some(command.env),
+                },
+                root_dir,
+                response
+                    .login
+                    .map(|login| task::SpawnInTerminal::from_proto(login)),
+            ))
+        })
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+}
+
+struct LocalGemini {
+    fs: Arc<dyn Fs>,
+    node_runtime: NodeRuntime,
+    project_environment: Entity<ProjectEnvironment>,
+    custom_command: Option<AgentServerCommand>,
+    ignore_system_version: bool,
+}
+
+impl ExternalAgentServer for LocalGemini {
+    fn get_command(
+        &mut self,
+        root_dir: Option<&str>,
+        extra_env: HashMap<String, String>,
+        status_tx: Option<watch::Sender<SharedString>>,
+        new_version_available_tx: Option<watch::Sender<Option<String>>>,
+        cx: &mut AsyncApp,
+    ) -> Task<Result<(AgentServerCommand, String, Option<task::SpawnInTerminal>)>> {
+        let fs = self.fs.clone();
+        let node_runtime = self.node_runtime.clone();
+        let project_environment = self.project_environment.downgrade();
+        let custom_command = self.custom_command.clone();
+        let ignore_system_version = self.ignore_system_version;
+        let root_dir: Arc<Path> = root_dir
+            .map(|root_dir| Path::new(root_dir))
+            .unwrap_or(paths::home_dir())
+            .into();
+
+        cx.spawn(async move |cx| {
+            let mut env = project_environment
+                .update(cx, |project_environment, cx| {
+                    project_environment.get_directory_environment(root_dir.clone(), cx)
+                })?
+                .await
+                .unwrap_or_default();
+
+            let mut command = if let Some(mut custom_command) = custom_command {
+                env.extend(custom_command.env.unwrap_or_default());
+                custom_command.env = Some(env);
+                custom_command
+            } else if !ignore_system_version
+                && let Some(bin) =
+                    find_bin_in_path("gemini".into(), root_dir.to_path_buf(), env.clone(), cx).await
+            {
+                AgentServerCommand {
+                    path: bin,
+                    args: Vec::new(),
+                    env: Some(env),
+                }
+            } else {
+                let mut command = get_or_npm_install_builtin_agent(
+                    GEMINI_NAME.into(),
+                    "@google/gemini-cli".into(),
+                    "node_modules/@google/gemini-cli/dist/index.js".into(),
+                    Some("0.2.1".parse().unwrap()),
+                    status_tx,
+                    new_version_available_tx,
+                    fs,
+                    node_runtime,
+                    cx,
+                )
+                .await?;
+                command.env = Some(env);
+                command
+            };
+
+            // Gemini CLI doesn't seem to have a dedicated invocation for logging in--we just run it normally without any arguments.
+            let login = task::SpawnInTerminal {
+                command: Some(command.path.clone().to_proto()),
+                args: command.args.clone(),
+                env: command.env.clone().unwrap_or_default(),
+                label: "gemini /auth".into(),
+                ..Default::default()
+            };
+
+            command.env.get_or_insert_default().extend(extra_env);
+            command.args.push("--experimental-acp".into());
+            Ok((command, root_dir.to_proto(), Some(login)))
+        })
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+}
+
+struct LocalClaudeCode {
+    fs: Arc<dyn Fs>,
+    node_runtime: NodeRuntime,
+    project_environment: Entity<ProjectEnvironment>,
+    custom_command: Option<AgentServerCommand>,
+}
+
+impl ExternalAgentServer for LocalClaudeCode {
+    fn get_command(
+        &mut self,
+        root_dir: Option<&str>,
+        extra_env: HashMap<String, String>,
+        status_tx: Option<watch::Sender<SharedString>>,
+        new_version_available_tx: Option<watch::Sender<Option<String>>>,
+        cx: &mut AsyncApp,
+    ) -> Task<Result<(AgentServerCommand, String, Option<task::SpawnInTerminal>)>> {
+        let fs = self.fs.clone();
+        let node_runtime = self.node_runtime.clone();
+        let project_environment = self.project_environment.downgrade();
+        let custom_command = self.custom_command.clone();
+        let root_dir: Arc<Path> = root_dir
+            .map(|root_dir| Path::new(root_dir))
+            .unwrap_or(paths::home_dir())
+            .into();
+
+        cx.spawn(async move |cx| {
+            let mut env = project_environment
+                .update(cx, |project_environment, cx| {
+                    project_environment.get_directory_environment(root_dir.clone(), cx)
+                })?
+                .await
+                .unwrap_or_default();
+            env.insert("ANTHROPIC_API_KEY".into(), "".into());
+
+            let (mut command, login) = if let Some(mut custom_command) = custom_command {
+                env.extend(custom_command.env.unwrap_or_default());
+                custom_command.env = Some(env);
+                (custom_command, None)
+            } else {
+                let mut command = get_or_npm_install_builtin_agent(
+                    "claude-code-acp".into(),
+                    "@zed-industries/claude-code-acp".into(),
+                    "node_modules/@zed-industries/claude-code-acp/dist/index.js".into(),
+                    Some("0.2.5".parse().unwrap()),
+                    status_tx,
+                    new_version_available_tx,
+                    fs,
+                    node_runtime,
+                    cx,
+                )
+                .await?;
+                command.env = Some(env);
+                let login = command
+                    .args
+                    .first()
+                    .and_then(|path| {
+                        path.strip_suffix("/@zed-industries/claude-code-acp/dist/index.js")
+                    })
+                    .map(|path_prefix| task::SpawnInTerminal {
+                        command: Some(command.path.clone().to_proto()),
+                        args: vec![
+                            Path::new(path_prefix)
+                                .join("@anthropic-ai/claude-code/cli.js")
+                                .to_string_lossy()
+                                .to_string(),
+                            "/login".into(),
+                        ],
+                        env: command.env.clone().unwrap_or_default(),
+                        label: "claude /login".into(),
+                        ..Default::default()
+                    });
+                (command, login)
+            };
+
+            command.env.get_or_insert_default().extend(extra_env);
+            Ok((command, root_dir.to_proto(), login))
+        })
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+}
+
+struct LocalCustomAgent {
+    project_environment: Entity<ProjectEnvironment>,
+    command: AgentServerCommand,
+}
+
+impl ExternalAgentServer for LocalCustomAgent {
+    fn get_command(
+        &mut self,
+        root_dir: Option<&str>,
+        extra_env: HashMap<String, String>,
+        _status_tx: Option<watch::Sender<SharedString>>,
+        _new_version_available_tx: Option<watch::Sender<Option<String>>>,
+        cx: &mut AsyncApp,
+    ) -> Task<Result<(AgentServerCommand, String, Option<task::SpawnInTerminal>)>> {
+        let mut command = self.command.clone();
+        let root_dir: Arc<Path> = root_dir
+            .map(|root_dir| Path::new(root_dir))
+            .unwrap_or(paths::home_dir())
+            .into();
+        let project_environment = self.project_environment.downgrade();
+        cx.spawn(async move |cx| {
+            let mut env = project_environment
+                .update(cx, |project_environment, cx| {
+                    project_environment.get_directory_environment(root_dir.clone(), cx)
+                })?
+                .await
+                .unwrap_or_default();
+            env.extend(command.env.unwrap_or_default());
+            env.extend(extra_env);
+            command.env = Some(env);
+            Ok((command, root_dir.to_proto(), None))
+        })
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+}
+
+pub const GEMINI_NAME: &'static str = "gemini";
+pub const CLAUDE_CODE_NAME: &'static str = "claude";
+
+#[derive(
+    Default, Deserialize, Serialize, Clone, JsonSchema, Debug, SettingsUi, SettingsKey, PartialEq,
+)]
+#[settings_key(key = "agent_servers")]
+pub struct AllAgentServersSettings {
+    pub gemini: Option<BuiltinAgentServerSettings>,
+    pub claude: Option<CustomAgentServerSettings>,
+
+    /// Custom agent servers configured by the user
+    #[serde(flatten)]
+    pub custom: HashMap<SharedString, CustomAgentServerSettings>,
+}
+
+#[derive(Default, Deserialize, Serialize, Clone, JsonSchema, Debug, PartialEq)]
+pub struct BuiltinAgentServerSettings {
+    /// Absolute path to a binary to be used when launching this agent.
+    ///
+    /// This can be used to run a specific binary without automatic downloads or searching `$PATH`.
+    #[serde(rename = "command")]
+    pub path: Option<PathBuf>,
+    /// If a binary is specified in `command`, it will be passed these arguments.
+    pub args: Option<Vec<String>>,
+    /// If a binary is specified in `command`, it will be passed these environment variables.
+    pub env: Option<HashMap<String, String>>,
+    /// Whether to skip searching `$PATH` for an agent server binary when
+    /// launching this agent.
+    ///
+    /// This has no effect if a `command` is specified. Otherwise, when this is
+    /// `false`, Zed will search `$PATH` for an agent server binary and, if one
+    /// is found, use it for threads with this agent. If no agent binary is
+    /// found on `$PATH`, Zed will automatically install and use its own binary.
+    /// When this is `true`, Zed will not search `$PATH`, and will always use
+    /// its own binary.
+    ///
+    /// Default: true
+    pub ignore_system_version: Option<bool>,
+}
+
+impl BuiltinAgentServerSettings {
+    pub(crate) fn custom_command(self) -> Option<AgentServerCommand> {
+        self.path.map(|path| AgentServerCommand {
+            path,
+            args: self.args.unwrap_or_default(),
+            env: self.env,
+        })
+    }
+}
+
+impl From<AgentServerCommand> for BuiltinAgentServerSettings {
+    fn from(value: AgentServerCommand) -> Self {
+        BuiltinAgentServerSettings {
+            path: Some(value.path),
+            args: Some(value.args),
+            env: value.env,
+            ..Default::default()
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize, Clone, JsonSchema, Debug, PartialEq)]
+pub struct CustomAgentServerSettings {
+    #[serde(flatten)]
+    pub command: AgentServerCommand,
+}
+
+impl settings::Settings for AllAgentServersSettings {
+    type FileContent = Self;
+
+    fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
+        let mut settings = AllAgentServersSettings::default();
+
+        for AllAgentServersSettings {
+            gemini,
+            claude,
+            custom,
+        } in sources.defaults_and_customizations()
+        {
+            if gemini.is_some() {
+                settings.gemini = gemini.clone();
+            }
+            if claude.is_some() {
+                settings.claude = claude.clone();
+            }
+
+            // Merge custom agents
+            for (name, config) in custom {
+                // Skip built-in agent names to avoid conflicts
+                if name != GEMINI_NAME && name != CLAUDE_CODE_NAME {
+                    settings.custom.insert(name.clone(), config.clone());
+                }
+            }
+        }
+
+        Ok(settings)
+    }
+
+    fn import_from_vscode(_vscode: &settings::VsCodeSettings, _current: &mut Self::FileContent) {}
+}
diff --git a/crates/project/src/buffer_store.rs b/crates/project/src/buffer_store.rs
index 89bd4b27c9c47470a781e0ff322f5ef4a29b4927..07f8e0c95cf8551803d5f5828703dbec090fcedb 100644
--- a/crates/project/src/buffer_store.rs
+++ b/crates/project/src/buffer_store.rs
@@ -319,7 +319,11 @@ impl RemoteBufferStore {
         })
     }
 
-    fn create_buffer(&self, cx: &mut Context<BufferStore>) -> Task<Result<Entity<Buffer>>> {
+    fn create_buffer(
+        &self,
+        project_searchable: bool,
+        cx: &mut Context<BufferStore>,
+    ) -> Task<Result<Entity<Buffer>>> {
         let create = self.upstream_client.request(proto::OpenNewBuffer {
             project_id: self.project_id,
         });
@@ -327,8 +331,13 @@ impl RemoteBufferStore {
             let response = create.await?;
             let buffer_id = BufferId::new(response.buffer_id)?;
 
-            this.update(cx, |this, cx| this.wait_for_remote_buffer(buffer_id, cx))?
-                .await
+            this.update(cx, |this, cx| {
+                if !project_searchable {
+                    this.non_searchable_buffers.insert(buffer_id);
+                }
+                this.wait_for_remote_buffer(buffer_id, cx)
+            })?
+            .await
         })
     }
 
@@ -473,6 +482,7 @@ impl LocalBufferStore {
             Some(buffer)
         } else {
             this.opened_buffers.remove(&buffer_id);
+            this.non_searchable_buffers.remove(&buffer_id);
             None
         };
 
@@ -670,12 +680,21 @@ impl LocalBufferStore {
         })
     }
 
-    fn create_buffer(&self, cx: &mut Context<BufferStore>) -> Task<Result<Entity<Buffer>>> {
+    fn create_buffer(
+        &self,
+        project_searchable: bool,
+        cx: &mut Context<BufferStore>,
+    ) -> Task<Result<Entity<Buffer>>> {
         cx.spawn(async move |buffer_store, cx| {
             let buffer =
                 cx.new(|cx| Buffer::local("", cx).with_language(language::PLAIN_TEXT.clone(), cx))?;
             buffer_store.update(cx, |buffer_store, cx| {
                 buffer_store.add_buffer(buffer.clone(), cx).log_err();
+                if !project_searchable {
+                    buffer_store
+                        .non_searchable_buffers
+                        .insert(buffer.read(cx).remote_id());
+                }
             })?;
             Ok(buffer)
         })
@@ -848,10 +867,14 @@ impl BufferStore {
         })
     }
 
-    pub fn create_buffer(&mut self, cx: &mut Context<Self>) -> Task<Result<Entity<Buffer>>> {
+    pub fn create_buffer(
+        &mut self,
+        project_searchable: bool,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<Entity<Buffer>>> {
         match &self.state {
-            BufferStoreState::Local(this) => this.create_buffer(cx),
-            BufferStoreState::Remote(this) => this.create_buffer(cx),
+            BufferStoreState::Local(this) => this.create_buffer(project_searchable, cx),
+            BufferStoreState::Remote(this) => this.create_buffer(project_searchable, cx),
         }
     }
 
@@ -1610,6 +1633,7 @@ impl BufferStore {
         &mut self,
         text: &str,
         language: Option<Arc<Language>>,
+        project_searchable: bool,
         cx: &mut Context<Self>,
     ) -> Entity<Buffer> {
         let buffer = cx.new(|cx| {
@@ -1619,6 +1643,9 @@ impl BufferStore {
 
         self.add_buffer(buffer.clone(), cx).log_err();
         let buffer_id = buffer.read(cx).remote_id();
+        if !project_searchable {
+            self.non_searchable_buffers.insert(buffer_id);
+        }
 
         if let Some(file) = File::from_dyn(buffer.read(cx).file()) {
             self.path_to_buffer_id.insert(
@@ -1688,10 +1715,6 @@ impl BufferStore {
         }
         serialized_transaction
     }
-
-    pub(crate) fn mark_buffer_as_non_searchable(&mut self, buffer_id: BufferId) {
-        self.non_searchable_buffers.insert(buffer_id);
-    }
 }
 
 impl OpenBuffer {
diff --git a/crates/project/src/git_store.rs b/crates/project/src/git_store.rs
index b7ff3e7fefc9b2e8aede04d3cd0fca88c16c2a62..92c68f6646654eee773fbdfad71f2df63b8f8dbd 100644
--- a/crates/project/src/git_store.rs
+++ b/crates/project/src/git_store.rs
@@ -3317,7 +3317,7 @@ impl Repository {
     ) -> Task<Result<Entity<Buffer>>> {
         cx.spawn(async move |repository, cx| {
             let buffer = buffer_store
-                .update(cx, |buffer_store, cx| buffer_store.create_buffer(cx))?
+                .update(cx, |buffer_store, cx| buffer_store.create_buffer(false, cx))?
                 .await?;
 
             if let Some(language_registry) = language_registry {
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 36ec338fb71ca1a130657dca1db037051691ad9d..d17188bfbf100963a5dd171f590dd77c6ffef9b2 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -86,7 +86,6 @@ use node_runtime::read_package_installed_version;
 use parking_lot::Mutex;
 use postage::{mpsc, sink::Sink, stream::Stream, watch};
 use rand::prelude::*;
-
 use rpc::{
     AnyProtoClient,
     proto::{FromProto, LspRequestId, LspRequestMessage as _, ToProto},
@@ -3761,7 +3760,7 @@ impl LspStore {
             worktree_store,
             languages: languages.clone(),
             language_server_statuses: Default::default(),
-            nonce: StdRng::from_entropy().r#gen(),
+            nonce: StdRng::from_os_rng().random(),
             diagnostic_summaries: HashMap::default(),
             lsp_server_capabilities: HashMap::default(),
             lsp_document_colors: HashMap::default(),
@@ -3823,7 +3822,7 @@ impl LspStore {
             worktree_store,
             languages: languages.clone(),
             language_server_statuses: Default::default(),
-            nonce: StdRng::from_entropy().r#gen(),
+            nonce: StdRng::from_os_rng().random(),
             diagnostic_summaries: HashMap::default(),
             lsp_server_capabilities: HashMap::default(),
             lsp_document_colors: HashMap::default(),
@@ -3933,8 +3932,8 @@ impl LspStore {
         event: &ToolchainStoreEvent,
         _: &mut Context<Self>,
     ) {
-        match event {
-            ToolchainStoreEvent::ToolchainActivated => self.request_workspace_config_refresh(),
+        if let ToolchainStoreEvent::ToolchainActivated = event {
+            self.request_workspace_config_refresh()
         }
     }
 
@@ -7124,6 +7123,36 @@ impl LspStore {
         summary
     }
 
+    /// Returns the diagnostic summary for a specific project path.
+    pub fn diagnostic_summary_for_path(
+        &self,
+        project_path: &ProjectPath,
+        _: &App,
+    ) -> DiagnosticSummary {
+        if let Some(summaries) = self
+            .diagnostic_summaries
+            .get(&project_path.worktree_id)
+            .and_then(|map| map.get(&project_path.path))
+        {
+            let (error_count, warning_count) = summaries.iter().fold(
+                (0, 0),
+                |(error_count, warning_count), (_language_server_id, summary)| {
+                    (
+                        error_count + summary.error_count,
+                        warning_count + summary.warning_count,
+                    )
+                },
+            );
+
+            DiagnosticSummary {
+                error_count,
+                warning_count,
+            }
+        } else {
+            DiagnosticSummary::default()
+        }
+    }
+
     pub fn diagnostic_summaries<'a>(
         &'a self,
         include_ignored: bool,
diff --git a/crates/project/src/lsp_store/log_store.rs b/crates/project/src/lsp_store/log_store.rs
index 67a20dd6cd8b2f5d6ca48d7790fc0b2e60aff370..00098712bf0092a6795de2ed48c7ccf15925c555 100644
--- a/crates/project/src/lsp_store/log_store.rs
+++ b/crates/project/src/lsp_store/log_store.rs
@@ -16,11 +16,6 @@ const SEND_LINE: &str = "\n// Send:";
 const RECEIVE_LINE: &str = "\n// Receive:";
 const MAX_STORED_LOG_ENTRIES: usize = 2000;
 
-const RPC_MESSAGES: &str = "RPC Messages";
-const SERVER_LOGS: &str = "Server Logs";
-const SERVER_TRACE: &str = "Server Trace";
-const SERVER_INFO: &str = "Server Info";
-
 pub fn init(on_headless_host: bool, cx: &mut App) -> Entity<LogStore> {
     let log_store = cx.new(|cx| LogStore::new(on_headless_host, cx));
     cx.set_global(GlobalLogStore(log_store.clone()));
@@ -216,15 +211,6 @@ impl LogKind {
             LanguageServerLogType::Rpc { .. } => Self::Rpc,
         }
     }
-
-    pub fn label(&self) -> &'static str {
-        match self {
-            LogKind::Rpc => RPC_MESSAGES,
-            LogKind::Trace => SERVER_TRACE,
-            LogKind::Logs => SERVER_LOGS,
-            LogKind::ServerInfo => SERVER_INFO,
-        }
-    }
 }
 
 impl LogStore {
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 46dd3b7d9e51aa06aa45b9cccb87533f2b90f58c..1ef3de7a166b785de7799269548cbddf7202ad0d 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -1,3 +1,4 @@
+pub mod agent_server_store;
 pub mod buffer_store;
 mod color_extractor;
 pub mod connection_manager;
@@ -28,12 +29,17 @@ use context_server_store::ContextServerStore;
 pub use environment::{EnvironmentErrorMessage, ProjectEnvironmentEvent};
 use git::repository::get_git_committer;
 use git_store::{Repository, RepositoryId};
+use schemars::JsonSchema;
 pub mod search_history;
 mod yarn;
 
 use dap::inline_value::{InlineValueLocation, VariableLookupKind, VariableScope};
 
-use crate::{git_store::GitStore, lsp_store::log_store::LogKind};
+use crate::{
+    agent_server_store::{AgentServerStore, AllAgentServersSettings},
+    git_store::GitStore,
+    lsp_store::log_store::LogKind,
+};
 pub use git_store::{
     ConflictRegion, ConflictSet, ConflictSetSnapshot, ConflictSetUpdate,
     git_traversal::{ChildEntriesGitIter, GitEntry, GitEntryRef, GitTraversal},
@@ -47,7 +53,7 @@ use clock::ReplicaId;
 
 use dap::client::DebugAdapterClient;
 
-use collections::{BTreeSet, HashMap, HashSet};
+use collections::{BTreeSet, HashMap, HashSet, IndexSet};
 use debounced_delay::DebouncedDelay;
 pub use debugger::breakpoint_store::BreakpointWithPosition;
 use debugger::{
@@ -73,8 +79,9 @@ use gpui::{
 };
 use language::{
     Buffer, BufferEvent, Capability, CodeLabel, CursorShape, Language, LanguageName,
-    LanguageRegistry, PointUtf16, ToOffset, ToPointUtf16, Toolchain, ToolchainList, Transaction,
-    Unclipped, language_settings::InlayHintKind, proto::split_operations,
+    LanguageRegistry, PointUtf16, ToOffset, ToPointUtf16, Toolchain, ToolchainMetadata,
+    ToolchainScope, Transaction, Unclipped, language_settings::InlayHintKind,
+    proto::split_operations,
 };
 use lsp::{
     CodeActionKind, CompletionContext, CompletionItemKind, DocumentHighlightKind, InsertTextMode,
@@ -94,12 +101,16 @@ use rpc::{
 };
 use search::{SearchInputKind, SearchQuery, SearchResult};
 use search_history::SearchHistory;
-use settings::{InvalidSettingsError, Settings, SettingsLocation, SettingsSources, SettingsStore};
+use settings::{
+    InvalidSettingsError, Settings, SettingsKey, SettingsLocation, SettingsSources, SettingsStore,
+    SettingsUi,
+};
 use smol::channel::Receiver;
 use snippet::Snippet;
 use snippet_provider::SnippetProvider;
 use std::{
     borrow::Cow,
+    collections::BTreeMap,
     ops::Range,
     path::{Component, Path, PathBuf},
     pin::pin,
@@ -113,7 +124,7 @@ use terminals::Terminals;
 use text::{Anchor, BufferId, OffsetRangeExt, Point, Rope};
 use toolchain_store::EmptyToolchainStore;
 use util::{
-    ResultExt as _,
+    ResultExt as _, maybe,
     paths::{PathStyle, RemotePathBuf, SanitizedPath, compare_paths},
 };
 use worktree::{CreatedEntry, Snapshot, Traversal};
@@ -138,7 +149,7 @@ pub use lsp_store::{
     LanguageServerStatus, LanguageServerToQuery, LspStore, LspStoreEvent,
     SERVER_PROGRESS_THROTTLE_TIMEOUT,
 };
-pub use toolchain_store::ToolchainStore;
+pub use toolchain_store::{ToolchainStore, Toolchains};
 const MAX_PROJECT_SEARCH_HISTORY_SIZE: usize = 500;
 const MAX_SEARCH_RESULT_FILES: usize = 5_000;
 const MAX_SEARCH_RESULT_RANGES: usize = 10_000;
@@ -173,6 +184,7 @@ pub struct Project {
     buffer_ordered_messages_tx: mpsc::UnboundedSender<BufferOrderedMessage>,
     languages: Arc<LanguageRegistry>,
     dap_store: Entity<DapStore>,
+    agent_server_store: Entity<AgentServerStore>,
 
     breakpoint_store: Entity<BreakpointStore>,
     collab_client: Arc<client::Client>,
@@ -968,10 +980,26 @@ pub struct DisableAiSettings {
     pub disable_ai: bool,
 }
 
-impl settings::Settings for DisableAiSettings {
-    const KEY: Option<&'static str> = Some("disable_ai");
+#[derive(
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    Debug,
+    Default,
+    serde::Serialize,
+    serde::Deserialize,
+    SettingsUi,
+    SettingsKey,
+    JsonSchema,
+)]
+#[settings_key(None)]
+pub struct DisableAiSettingContent {
+    pub disable_ai: Option<bool>,
+}
 
-    type FileContent = Option<bool>;
+impl settings::Settings for DisableAiSettings {
+    type FileContent = DisableAiSettingContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
         // For security reasons, settings can only make AI restrictions MORE strict, not less.
@@ -984,7 +1012,7 @@ impl settings::Settings for DisableAiSettings {
             .iter()
             .chain(sources.user.iter())
             .chain(sources.server.iter())
-            .any(|disabled| **disabled == Some(true));
+            .any(|disabled| disabled.disable_ai == Some(true));
 
         Ok(Self { disable_ai })
     }
@@ -997,6 +1025,7 @@ impl Project {
         WorktreeSettings::register(cx);
         ProjectSettings::register(cx);
         DisableAiSettings::register(cx);
+        AllAgentServersSettings::register(cx);
     }
 
     pub fn init(client: &Arc<Client>, cx: &mut App) {
@@ -1152,6 +1181,10 @@ impl Project {
                 )
             });
 
+            let agent_server_store = cx.new(|cx| {
+                AgentServerStore::local(node.clone(), fs.clone(), environment.clone(), cx)
+            });
+
             cx.subscribe(&lsp_store, Self::on_lsp_store_event).detach();
 
             Self {
@@ -1178,6 +1211,7 @@ impl Project {
                 remote_client: None,
                 breakpoint_store,
                 dap_store,
+                agent_server_store,
 
                 buffers_needing_diff: Default::default(),
                 git_diff_debouncer: DebouncedDelay::new(),
@@ -1271,6 +1305,7 @@ impl Project {
                     fs.clone(),
                     worktree_store.clone(),
                     task_store.clone(),
+                    Some(remote_proto.clone()),
                     cx,
                 )
             });
@@ -1315,6 +1350,9 @@ impl Project {
                 )
             });
 
+            let agent_server_store =
+                cx.new(|cx| AgentServerStore::remote(REMOTE_SERVER_PROJECT_ID, remote.clone(), cx));
+
             cx.subscribe(&remote, Self::on_remote_client_event).detach();
 
             let this = Self {
@@ -1330,6 +1368,7 @@ impl Project {
                 join_project_response_message_id: 0,
                 client_state: ProjectClientState::Local,
                 git_store,
+                agent_server_store,
                 client_subscriptions: Vec::new(),
                 _subscriptions: vec![
                     cx.on_release(Self::release),
@@ -1384,6 +1423,7 @@ impl Project {
             remote_proto.subscribe_to_entity(REMOTE_SERVER_PROJECT_ID, &this.dap_store);
             remote_proto.subscribe_to_entity(REMOTE_SERVER_PROJECT_ID, &this.settings_observer);
             remote_proto.subscribe_to_entity(REMOTE_SERVER_PROJECT_ID, &this.git_store);
+            remote_proto.subscribe_to_entity(REMOTE_SERVER_PROJECT_ID, &this.agent_server_store);
 
             remote_proto.add_entity_message_handler(Self::handle_create_buffer_for_peer);
             remote_proto.add_entity_message_handler(Self::handle_update_worktree);
@@ -1399,6 +1439,7 @@ impl Project {
             ToolchainStore::init(&remote_proto);
             DapStore::init(&remote_proto, cx);
             GitStore::init(&remote_proto);
+            AgentServerStore::init_remote(&remote_proto);
 
             this
         })
@@ -1521,7 +1562,13 @@ impl Project {
         })?;
 
         let settings_observer = cx.new(|cx| {
-            SettingsObserver::new_remote(fs.clone(), worktree_store.clone(), task_store.clone(), cx)
+            SettingsObserver::new_remote(
+                fs.clone(),
+                worktree_store.clone(),
+                task_store.clone(),
+                None,
+                cx,
+            )
         })?;
 
         let git_store = cx.new(|cx| {
@@ -1535,6 +1582,8 @@ impl Project {
             )
         })?;
 
+        let agent_server_store = cx.new(|cx| AgentServerStore::collab(cx))?;
+
         let project = cx.new(|cx| {
             let replica_id = response.payload.replica_id as ReplicaId;
 
@@ -1595,6 +1644,7 @@ impl Project {
                 breakpoint_store,
                 dap_store: dap_store.clone(),
                 git_store: git_store.clone(),
+                agent_server_store,
                 buffers_needing_diff: Default::default(),
                 git_diff_debouncer: DebouncedDelay::new(),
                 terminals: Terminals {
@@ -2511,22 +2561,28 @@ impl Project {
         }
     }
 
-    pub fn create_buffer(&mut self, cx: &mut Context<Self>) -> Task<Result<Entity<Buffer>>> {
-        self.buffer_store
-            .update(cx, |buffer_store, cx| buffer_store.create_buffer(cx))
+    pub fn create_buffer(
+        &mut self,
+        searchable: bool,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<Entity<Buffer>>> {
+        self.buffer_store.update(cx, |buffer_store, cx| {
+            buffer_store.create_buffer(searchable, cx)
+        })
     }
 
     pub fn create_local_buffer(
         &mut self,
         text: &str,
         language: Option<Arc<Language>>,
+        project_searchable: bool,
         cx: &mut Context<Self>,
     ) -> Entity<Buffer> {
         if self.is_via_collab() || self.is_via_remote_server() {
             panic!("called create_local_buffer on a remote project")
         }
         self.buffer_store.update(cx, |buffer_store, cx| {
-            buffer_store.create_local_buffer(text, language, cx)
+            buffer_store.create_local_buffer(text, language, project_searchable, cx)
         })
     }
 
@@ -3343,7 +3399,7 @@ impl Project {
         path: ProjectPath,
         language_name: LanguageName,
         cx: &App,
-    ) -> Task<Option<(ToolchainList, Arc<Path>)>> {
+    ) -> Task<Option<Toolchains>> {
         if let Some(toolchain_store) = self.toolchain_store.as_ref().map(Entity::downgrade) {
             cx.spawn(async move |cx| {
                 toolchain_store
@@ -3356,16 +3412,70 @@ impl Project {
         }
     }
 
-    pub async fn toolchain_term(
+    pub async fn toolchain_metadata(
         languages: Arc<LanguageRegistry>,
         language_name: LanguageName,
-    ) -> Option<SharedString> {
+    ) -> Option<ToolchainMetadata> {
         languages
             .language_for_name(language_name.as_ref())
             .await
             .ok()?
             .toolchain_lister()
-            .map(|lister| lister.term())
+            .map(|lister| lister.meta())
+    }
+
+    pub fn add_toolchain(
+        &self,
+        toolchain: Toolchain,
+        scope: ToolchainScope,
+        cx: &mut Context<Self>,
+    ) {
+        maybe!({
+            self.toolchain_store.as_ref()?.update(cx, |this, cx| {
+                this.add_toolchain(toolchain, scope, cx);
+            });
+            Some(())
+        });
+    }
+
+    pub fn remove_toolchain(
+        &self,
+        toolchain: Toolchain,
+        scope: ToolchainScope,
+        cx: &mut Context<Self>,
+    ) {
+        maybe!({
+            self.toolchain_store.as_ref()?.update(cx, |this, cx| {
+                this.remove_toolchain(toolchain, scope, cx);
+            });
+            Some(())
+        });
+    }
+
+    pub fn user_toolchains(
+        &self,
+        cx: &App,
+    ) -> Option<BTreeMap<ToolchainScope, IndexSet<Toolchain>>> {
+        Some(self.toolchain_store.as_ref()?.read(cx).user_toolchains())
+    }
+
+    pub fn resolve_toolchain(
+        &self,
+        path: PathBuf,
+        language_name: LanguageName,
+        cx: &App,
+    ) -> Task<Result<Toolchain>> {
+        if let Some(toolchain_store) = self.toolchain_store.as_ref().map(Entity::downgrade) {
+            cx.spawn(async move |cx| {
+                toolchain_store
+                    .update(cx, |this, cx| {
+                        this.resolve_toolchain(path, language_name, cx)
+                    })?
+                    .await
+            })
+        } else {
+            Task::ready(Err(anyhow!("This project does not support toolchains")))
+        }
     }
 
     pub fn toolchain_store(&self) -> Option<Entity<ToolchainStore>> {
@@ -4311,6 +4421,13 @@ impl Project {
             .diagnostic_summary(include_ignored, cx)
     }
 
+    /// Returns a summary of the diagnostics for the provided project path only.
+    pub fn diagnostic_summary_for_path(&self, path: &ProjectPath, cx: &App) -> DiagnosticSummary {
+        self.lsp_store
+            .read(cx)
+            .diagnostic_summary_for_path(path, cx)
+    }
+
     pub fn diagnostic_summaries<'a>(
         &'a self,
         include_ignored: bool,
@@ -4325,7 +4442,7 @@ impl Project {
         self.active_entry
     }
 
-    pub fn entry_for_path(&self, path: &ProjectPath, cx: &App) -> Option<Entry> {
+    pub fn entry_for_path<'a>(&'a self, path: &ProjectPath, cx: &'a App) -> Option<&'a Entry> {
         self.worktree_store.read(cx).entry_for_path(path, cx)
     }
 
@@ -4401,6 +4518,23 @@ impl Project {
         None
     }
 
+    /// If there's only one visible worktree, returns the given worktree-relative path with no prefix.
+    ///
+    /// Otherwise, returns the full path for the project path (obtained by prefixing the worktree-relative path with the name of the worktree).
+    pub fn short_full_path_for_project_path(
+        &self,
+        project_path: &ProjectPath,
+        cx: &App,
+    ) -> Option<PathBuf> {
+        if self.visible_worktrees(cx).take(2).count() < 2 {
+            return Some(project_path.path.to_path_buf());
+        }
+        self.worktree_for_id(project_path.worktree_id, cx)
+            .and_then(|worktree| {
+                Some(Path::new(worktree.read(cx).abs_path().file_name()?).join(&project_path.path))
+            })
+    }
+
     pub fn project_path_for_absolute_path(&self, abs_path: &Path, cx: &App) -> Option<ProjectPath> {
         self.find_worktree(abs_path, cx)
             .map(|(worktree, relative_path)| ProjectPath {
@@ -4830,7 +4964,7 @@ impl Project {
         mut cx: AsyncApp,
     ) -> Result<proto::OpenBufferResponse> {
         let buffer = this
-            .update(&mut cx, |this, cx| this.create_buffer(cx))?
+            .update(&mut cx, |this, cx| this.create_buffer(true, cx))?
             .await?;
         let peer_id = envelope.original_sender_id()?;
 
@@ -5086,6 +5220,10 @@ impl Project {
         &self.git_store
     }
 
+    pub fn agent_server_store(&self) -> &Entity<AgentServerStore> {
+        &self.agent_server_store
+    }
+
     #[cfg(test)]
     fn git_scans_complete(&self, cx: &Context<Self>) -> Task<()> {
         cx.spawn(async move |this, cx| {
@@ -5161,12 +5299,6 @@ impl Project {
     pub fn agent_location(&self) -> Option<AgentLocation> {
         self.agent_location.clone()
     }
-
-    pub fn mark_buffer_as_non_searchable(&self, buffer_id: BufferId, cx: &mut Context<Project>) {
-        self.buffer_store.update(cx, |buffer_store, _| {
-            buffer_store.mark_buffer_as_non_searchable(buffer_id)
-        });
-    }
 }
 
 pub struct PathMatchCandidateSet {
@@ -5543,10 +5675,15 @@ mod disable_ai_settings_tests {
 
     #[gpui::test]
     async fn test_disable_ai_settings_security(cx: &mut TestAppContext) {
+        fn disable_setting(value: Option<bool>) -> DisableAiSettingContent {
+            DisableAiSettingContent { disable_ai: value }
+        }
         cx.update(|cx| {
             // Test 1: Default is false (AI enabled)
             let sources = SettingsSources {
-                default: &Some(false),
+                default: &DisableAiSettingContent {
+                    disable_ai: Some(false),
+                },
                 global: None,
                 extensions: None,
                 user: None,
@@ -5560,10 +5697,10 @@ mod disable_ai_settings_tests {
             assert!(!settings.disable_ai, "Default should allow AI");
 
             // Test 2: Global true, local false -> still disabled (local cannot re-enable)
-            let global_true = Some(true);
-            let local_false = Some(false);
+            let global_true = disable_setting(Some(true));
+            let local_false = disable_setting(Some(false));
             let sources = SettingsSources {
-                default: &Some(false),
+                default: &disable_setting(Some(false)),
                 global: None,
                 extensions: None,
                 user: Some(&global_true),
@@ -5580,10 +5717,10 @@ mod disable_ai_settings_tests {
             );
 
             // Test 3: Global false, local true -> disabled (local can make more restrictive)
-            let global_false = Some(false);
-            let local_true = Some(true);
+            let global_false = disable_setting(Some(false));
+            let local_true = disable_setting(Some(true));
             let sources = SettingsSources {
-                default: &Some(false),
+                default: &disable_setting(Some(false)),
                 global: None,
                 extensions: None,
                 user: Some(&global_false),
@@ -5597,10 +5734,10 @@ mod disable_ai_settings_tests {
             assert!(settings.disable_ai, "Local true can override global false");
 
             // Test 4: Server can only make more restrictive (set to true)
-            let user_false = Some(false);
-            let server_true = Some(true);
+            let user_false = disable_setting(Some(false));
+            let server_true = disable_setting(Some(true));
             let sources = SettingsSources {
-                default: &Some(false),
+                default: &disable_setting(Some(false)),
                 global: None,
                 extensions: None,
                 user: Some(&user_false),
@@ -5617,10 +5754,10 @@ mod disable_ai_settings_tests {
             );
 
             // Test 5: Server false cannot override user true
-            let user_true = Some(true);
-            let server_false = Some(false);
+            let user_true = disable_setting(Some(true));
+            let server_false = disable_setting(Some(false));
             let sources = SettingsSources {
-                default: &Some(false),
+                default: &disable_setting(Some(false)),
                 global: None,
                 extensions: None,
                 user: Some(&user_true),
@@ -5637,12 +5774,12 @@ mod disable_ai_settings_tests {
             );
 
             // Test 6: Multiple local settings, any true disables AI
-            let global_false = Some(false);
-            let local_false3 = Some(false);
-            let local_true2 = Some(true);
-            let local_false4 = Some(false);
+            let global_false = disable_setting(Some(false));
+            let local_false3 = disable_setting(Some(false));
+            let local_true2 = disable_setting(Some(true));
+            let local_false4 = disable_setting(Some(false));
             let sources = SettingsSources {
-                default: &Some(false),
+                default: &disable_setting(Some(false)),
                 global: None,
                 extensions: None,
                 user: Some(&global_false),
@@ -5656,11 +5793,11 @@ mod disable_ai_settings_tests {
             assert!(settings.disable_ai, "Any local true should disable AI");
 
             // Test 7: All three sources can independently disable AI
-            let user_false2 = Some(false);
-            let server_false2 = Some(false);
-            let local_true3 = Some(true);
+            let user_false2 = disable_setting(Some(false));
+            let server_false2 = disable_setting(Some(false));
+            let local_true3 = disable_setting(Some(true));
             let sources = SettingsSources {
-                default: &Some(false),
+                default: &disable_setting(Some(false)),
                 global: None,
                 extensions: None,
                 user: Some(&user_false2),
diff --git a/crates/project/src/project_settings.rs b/crates/project/src/project_settings.rs
index c98065116e00fd6c643a2c809cf6e8fb1c51532b..694e244e63e2b2861d640ec32ce0a1f5c50be52f 100644
--- a/crates/project/src/project_settings.rs
+++ b/crates/project/src/project_settings.rs
@@ -4,7 +4,7 @@ use context_server::ContextServerCommand;
 use dap::adapters::DebugAdapterName;
 use fs::Fs;
 use futures::StreamExt as _;
-use gpui::{App, AsyncApp, BorrowAppContext, Context, Entity, EventEmitter, Task};
+use gpui::{App, AsyncApp, BorrowAppContext, Context, Entity, EventEmitter, Subscription, Task};
 use lsp::LanguageServerName;
 use paths::{
     EDITORCONFIG_NAME, local_debug_file_relative_path, local_settings_file_relative_path,
@@ -13,13 +13,13 @@ use paths::{
 };
 use rpc::{
     AnyProtoClient, TypedEnvelope,
-    proto::{self, FromProto, ToProto},
+    proto::{self, FromProto, REMOTE_SERVER_PROJECT_ID, ToProto},
 };
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{
-    InvalidSettingsError, LocalSettingsKind, Settings, SettingsLocation, SettingsSources,
-    SettingsStore, SettingsUi, parse_json_with_comments, watch_config_file,
+    InvalidSettingsError, LocalSettingsKind, Settings, SettingsKey, SettingsLocation,
+    SettingsSources, SettingsStore, SettingsUi, parse_json_with_comments, watch_config_file,
 };
 use std::{
     collections::BTreeMap,
@@ -36,7 +36,8 @@ use crate::{
     worktree_store::{WorktreeStore, WorktreeStoreEvent},
 };
 
-#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi)]
+#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey)]
+#[settings_key(None)]
 pub struct ProjectSettings {
     /// Configuration for language servers.
     ///
@@ -568,8 +569,6 @@ impl Default for SessionSettings {
 }
 
 impl Settings for ProjectSettings {
-    const KEY: Option<&'static str> = None;
-
     type FileContent = Self;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> anyhow::Result<Self> {
@@ -658,6 +657,7 @@ pub struct SettingsObserver {
     worktree_store: Entity<WorktreeStore>,
     project_id: u64,
     task_store: Entity<TaskStore>,
+    _user_settings_watcher: Option<Subscription>,
     _global_task_config_watcher: Task<()>,
     _global_debug_config_watcher: Task<()>,
 }
@@ -670,6 +670,7 @@ pub struct SettingsObserver {
 impl SettingsObserver {
     pub fn init(client: &AnyProtoClient) {
         client.add_entity_message_handler(Self::handle_update_worktree_settings);
+        client.add_entity_message_handler(Self::handle_update_user_settings);
     }
 
     pub fn new_local(
@@ -686,7 +687,8 @@ impl SettingsObserver {
             task_store,
             mode: SettingsObserverMode::Local(fs.clone()),
             downstream_client: None,
-            project_id: 0,
+            _user_settings_watcher: None,
+            project_id: REMOTE_SERVER_PROJECT_ID,
             _global_task_config_watcher: Self::subscribe_to_global_task_file_changes(
                 fs.clone(),
                 paths::tasks_file().clone(),
@@ -704,14 +706,38 @@ impl SettingsObserver {
         fs: Arc<dyn Fs>,
         worktree_store: Entity<WorktreeStore>,
         task_store: Entity<TaskStore>,
+        upstream_client: Option<AnyProtoClient>,
         cx: &mut Context<Self>,
     ) -> Self {
+        let mut user_settings_watcher = None;
+        if cx.try_global::<SettingsStore>().is_some() {
+            if let Some(upstream_client) = upstream_client {
+                let mut user_settings = None;
+                user_settings_watcher = Some(cx.observe_global::<SettingsStore>(move |_, cx| {
+                    let new_settings = cx.global::<SettingsStore>().raw_user_settings();
+                    if Some(new_settings) != user_settings.as_ref() {
+                        if let Some(new_settings_string) = serde_json::to_string(new_settings).ok()
+                        {
+                            user_settings = Some(new_settings.clone());
+                            upstream_client
+                                .send(proto::UpdateUserSettings {
+                                    project_id: REMOTE_SERVER_PROJECT_ID,
+                                    contents: new_settings_string,
+                                })
+                                .log_err();
+                        }
+                    }
+                }));
+            }
+        };
+
         Self {
             worktree_store,
             task_store,
             mode: SettingsObserverMode::Remote,
             downstream_client: None,
-            project_id: 0,
+            project_id: REMOTE_SERVER_PROJECT_ID,
+            _user_settings_watcher: user_settings_watcher,
             _global_task_config_watcher: Self::subscribe_to_global_task_file_changes(
                 fs.clone(),
                 paths::tasks_file().clone(),
@@ -803,6 +829,24 @@ impl SettingsObserver {
         Ok(())
     }
 
+    async fn handle_update_user_settings(
+        _: Entity<Self>,
+        envelope: TypedEnvelope<proto::UpdateUserSettings>,
+        cx: AsyncApp,
+    ) -> anyhow::Result<()> {
+        let new_settings = serde_json::from_str::<serde_json::Value>(&envelope.payload.contents)
+            .with_context(|| {
+                format!("deserializing {} user settings", envelope.payload.contents)
+            })?;
+        cx.update_global(|settings_store: &mut SettingsStore, cx| {
+            settings_store
+                .set_raw_user_settings(new_settings, cx)
+                .context("setting new user settings")?;
+            anyhow::Ok(())
+        })??;
+        Ok(())
+    }
+
     fn on_worktree_store_event(
         &mut self,
         _: Entity<WorktreeStore>,
@@ -1089,7 +1133,7 @@ impl SettingsObserver {
                         project_id: self.project_id,
                         worktree_id: remote_worktree_id.to_proto(),
                         path: directory.to_proto(),
-                        content: file_content,
+                        content: file_content.clone(),
                         kind: Some(local_settings_kind_to_proto(kind).into()),
                     })
                     .log_err();
diff --git a/crates/project/src/project_tests.rs b/crates/project/src/project_tests.rs
index a07f94fb737745b22bf6eaf685e1a4f2874a4dae..c72f35833b43291f916958f20ce96876976dfc7e 100644
--- a/crates/project/src/project_tests.rs
+++ b/crates/project/src/project_tests.rs
@@ -22,7 +22,7 @@ use itertools::Itertools;
 use language::{
     Diagnostic, DiagnosticEntry, DiagnosticSet, DiagnosticSourceKind, DiskState, FakeLspAdapter,
     LanguageConfig, LanguageMatcher, LanguageName, LineEnding, ManifestName, ManifestProvider,
-    ManifestQuery, OffsetRangeExt, Point, ToPoint, ToolchainLister,
+    ManifestQuery, OffsetRangeExt, Point, ToPoint, ToolchainList, ToolchainLister,
     language_settings::{AllLanguageSettings, LanguageSettingsContent, language_settings},
     tree_sitter_rust, tree_sitter_typescript,
 };
@@ -727,7 +727,12 @@ async fn test_running_multiple_instances_of_a_single_server_in_one_worktree(
     // We're not using venvs at all here, so both folders should fall under the same root.
     assert_eq!(server.server_id(), LanguageServerId(0));
     // Now, let's select a different toolchain for one of subprojects.
-    let (available_toolchains_for_b, root_path) = project
+
+    let Toolchains {
+        toolchains: available_toolchains_for_b,
+        root_path,
+        ..
+    } = project
         .update(cx, |this, cx| {
             let worktree_id = this.worktrees(cx).next().unwrap().read(cx).id();
             this.available_toolchains(
@@ -3871,7 +3876,7 @@ async fn test_save_file_spawns_language_server(cx: &mut gpui::TestAppContext) {
     );
 
     let buffer = project
-        .update(cx, |this, cx| this.create_buffer(cx))
+        .update(cx, |this, cx| this.create_buffer(false, cx))
         .unwrap()
         .await;
     project.update(cx, |this, cx| {
@@ -4083,7 +4088,9 @@ async fn test_save_as(cx: &mut gpui::TestAppContext) {
     let languages = project.update(cx, |project, _| project.languages().clone());
     languages.add(rust_lang());
 
-    let buffer = project.update(cx, |project, cx| project.create_local_buffer("", None, cx));
+    let buffer = project.update(cx, |project, cx| {
+        project.create_local_buffer("", None, false, cx)
+    });
     buffer.update(cx, |buffer, cx| {
         buffer.edit([(0..0, "abc")], None, cx);
         assert!(buffer.is_dirty());
@@ -5580,9 +5587,7 @@ async fn test_search_with_buffer_exclusions(cx: &mut gpui::TestAppContext) {
 
     let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
     let _buffer = project.update(cx, |project, cx| {
-        let buffer = project.create_local_buffer("file", None, cx);
-        project.mark_buffer_as_non_searchable(buffer.read(cx).remote_id(), cx);
-        buffer
+        project.create_local_buffer("file", None, false, cx)
     });
 
     assert_eq!(
@@ -7661,7 +7666,7 @@ async fn test_staging_random_hunks(
         .unwrap_or(20);
 
     // Try to induce races between diff recalculation and index writes.
-    if rng.gen_bool(0.5) {
+    if rng.random_bool(0.5) {
         executor.deprioritize(*CALCULATE_DIFF_TASK);
     }
 
@@ -7717,7 +7722,7 @@ async fn test_staging_random_hunks(
     assert_eq!(hunks.len(), 6);
 
     for _i in 0..operations {
-        let hunk_ix = rng.gen_range(0..hunks.len());
+        let hunk_ix = rng.random_range(0..hunks.len());
         let hunk = &mut hunks[hunk_ix];
         let row = hunk.range.start.row;
 
@@ -7735,7 +7740,7 @@ async fn test_staging_random_hunks(
             hunk.secondary_status = SecondaryHunkAdditionPending;
         }
 
-        for _ in 0..rng.gen_range(0..10) {
+        for _ in 0..rng.random_range(0..10) {
             log::info!("yielding");
             cx.executor().simulate_random_delay().await;
         }
@@ -9213,13 +9218,21 @@ fn python_lang(fs: Arc<FakeFs>) -> Arc<Language> {
                 ..Default::default()
             }
         }
-        // Returns a term which we should use in UI to refer to a toolchain.
-        fn term(&self) -> SharedString {
-            SharedString::new_static("virtual environment")
+        async fn resolve(
+            &self,
+            _: PathBuf,
+            _: Option<HashMap<String, String>>,
+        ) -> anyhow::Result<Toolchain> {
+            Err(anyhow::anyhow!("Not implemented"))
         }
-        /// Returns the name of the manifest file for this toolchain.
-        fn manifest_name(&self) -> ManifestName {
-            SharedString::new_static("pyproject.toml").into()
+        fn meta(&self) -> ToolchainMetadata {
+            ToolchainMetadata {
+                term: SharedString::new_static("Virtual Environment"),
+                new_toolchain_placeholder: SharedString::new_static(
+                    "A path to the python3 executable within a virtual environment, or path to virtual environment itself",
+                ),
+                manifest_name: ManifestName::from(SharedString::new_static("pyproject.toml")),
+            }
         }
         async fn activation_script(&self, _: &Toolchain, _: ShellKind, _: &dyn Fs) -> Vec<String> {
             vec![]
diff --git a/crates/project/src/terminals.rs b/crates/project/src/terminals.rs
index 8789366d1d40111b679dc83d34b57e62e360ab51..e7733e53803c8d7073ab6fe0255da70264224258 100644
--- a/crates/project/src/terminals.rs
+++ b/crates/project/src/terminals.rs
@@ -49,14 +49,6 @@ impl Project {
         cx: &mut Context<Self>,
     ) -> Task<Result<Entity<Terminal>>> {
         let is_via_remote = self.remote_client.is_some();
-        let project_path_context = self
-            .active_entry()
-            .and_then(|entry_id| self.worktree_id_for_entry(entry_id, cx))
-            .or_else(|| self.visible_worktrees(cx).next().map(|wt| wt.read(cx).id()))
-            .map(|worktree_id| ProjectPath {
-                worktree_id,
-                path: Arc::from(Path::new("")),
-            });
 
         let path: Option<Arc<Path>> = if let Some(cwd) = &spawn_task.cwd {
             if is_via_remote {
@@ -124,23 +116,42 @@ impl Project {
             },
         };
 
-        let toolchain = project_path_context
+        let project_path_contexts = self
+            .active_entry()
+            .and_then(|entry_id| self.path_for_entry(entry_id, cx))
+            .into_iter()
+            .chain(
+                self.visible_worktrees(cx)
+                    .map(|wt| wt.read(cx).id())
+                    .map(|worktree_id| ProjectPath {
+                        worktree_id,
+                        path: Arc::from(Path::new("")),
+                    }),
+            );
+        let toolchains = project_path_contexts
             .filter(|_| detect_venv)
-            .map(|p| self.active_toolchain(p, LanguageName::new("Python"), cx));
+            .map(|p| self.active_toolchain(p, LanguageName::new("Python"), cx))
+            .collect::<Vec<_>>();
         let lang_registry = self.languages.clone();
         let fs = self.fs.clone();
         cx.spawn(async move |project, cx| {
             let activation_script = maybe!(async {
-                let toolchain = toolchain?.await?;
-                Some(
-                    lang_registry
+                for toolchain in toolchains {
+                    let Some(toolchain) = toolchain.await else {
+                        continue;
+                    };
+                    let language = lang_registry
                         .language_for_name(&toolchain.language_name.0)
                         .await
-                        .ok()?
-                        .toolchain_lister()?
-                        .activation_script(&toolchain, ShellKind::new(&shell), fs.as_ref())
-                        .await,
-                )
+                        .ok();
+                    let lister = language?.toolchain_lister();
+                    return Some(
+                        lister?
+                            .activation_script(&toolchain, ShellKind::new(&shell), fs.as_ref())
+                            .await,
+                    );
+                }
+                None
             })
             .await
             .unwrap_or_default();
@@ -268,14 +279,6 @@ impl Project {
         cwd: Option<PathBuf>,
         cx: &mut Context<Self>,
     ) -> Task<Result<Entity<Terminal>>> {
-        let project_path_context = self
-            .active_entry()
-            .and_then(|entry_id| self.worktree_id_for_entry(entry_id, cx))
-            .or_else(|| self.visible_worktrees(cx).next().map(|wt| wt.read(cx).id()))
-            .map(|worktree_id| ProjectPath {
-                worktree_id,
-                path: Arc::from(Path::new("")),
-            });
         let path = cwd.map(|p| Arc::from(&*p));
         let is_via_remote = self.remote_client.is_some();
 
@@ -303,9 +306,22 @@ impl Project {
 
         let local_path = if is_via_remote { None } else { path.clone() };
 
-        let toolchain = project_path_context
+        let project_path_contexts = self
+            .active_entry()
+            .and_then(|entry_id| self.path_for_entry(entry_id, cx))
+            .into_iter()
+            .chain(
+                self.visible_worktrees(cx)
+                    .map(|wt| wt.read(cx).id())
+                    .map(|worktree_id| ProjectPath {
+                        worktree_id,
+                        path: Arc::from(Path::new("")),
+                    }),
+            );
+        let toolchains = project_path_contexts
             .filter(|_| detect_venv)
-            .map(|p| self.active_toolchain(p, LanguageName::new("Python"), cx));
+            .map(|p| self.active_toolchain(p, LanguageName::new("Python"), cx))
+            .collect::<Vec<_>>();
         let remote_client = self.remote_client.clone();
         let shell = match &remote_client {
             Some(remote_client) => remote_client
@@ -327,17 +343,22 @@ impl Project {
         let fs = self.fs.clone();
         cx.spawn(async move |project, cx| {
             let activation_script = maybe!(async {
-                let toolchain = toolchain?.await?;
-                let language = lang_registry
-                    .language_for_name(&toolchain.language_name.0)
-                    .await
-                    .ok();
-                let lister = language?.toolchain_lister();
-                Some(
-                    lister?
-                        .activation_script(&toolchain, ShellKind::new(&shell), fs.as_ref())
-                        .await,
-                )
+                for toolchain in toolchains {
+                    let Some(toolchain) = toolchain.await else {
+                        continue;
+                    };
+                    let language = lang_registry
+                        .language_for_name(&toolchain.language_name.0)
+                        .await
+                        .ok();
+                    let lister = language?.toolchain_lister();
+                    return Some(
+                        lister?
+                            .activation_script(&toolchain, ShellKind::new(&shell), fs.as_ref())
+                            .await,
+                    );
+                }
+                None
             })
             .await
             .unwrap_or_default();
diff --git a/crates/project/src/toolchain_store.rs b/crates/project/src/toolchain_store.rs
index 57d492e26fc7b59df02df0128ed6b9ade132c6d9..e76b98f697768c987f527eaf444c159334b12c96 100644
--- a/crates/project/src/toolchain_store.rs
+++ b/crates/project/src/toolchain_store.rs
@@ -4,20 +4,23 @@ use std::{
     sync::Arc,
 };
 
-use anyhow::{Result, bail};
+use anyhow::{Context as _, Result, bail};
 
 use async_trait::async_trait;
-use collections::BTreeMap;
+use collections::{BTreeMap, IndexSet};
 use gpui::{
     App, AppContext as _, AsyncApp, Context, Entity, EventEmitter, Subscription, Task, WeakEntity,
 };
 use language::{
     LanguageName, LanguageRegistry, LanguageToolchainStore, ManifestDelegate, Toolchain,
-    ToolchainList,
+    ToolchainList, ToolchainScope,
 };
 use rpc::{
     AnyProtoClient, TypedEnvelope,
-    proto::{self, FromProto, ToProto},
+    proto::{
+        self, FromProto, ResolveToolchainResponse, ToProto,
+        resolve_toolchain_response::Response as ResolveResponsePayload,
+    },
 };
 use settings::WorktreeId;
 use util::ResultExt as _;
@@ -28,24 +31,31 @@ use crate::{
     worktree_store::WorktreeStore,
 };
 
-pub struct ToolchainStore(ToolchainStoreInner);
+pub struct ToolchainStore {
+    mode: ToolchainStoreInner,
+    user_toolchains: BTreeMap<ToolchainScope, IndexSet<Toolchain>>,
+    _sub: Subscription,
+}
+
 enum ToolchainStoreInner {
-    Local(
-        Entity<LocalToolchainStore>,
-        #[allow(dead_code)] Subscription,
-    ),
-    Remote(
-        Entity<RemoteToolchainStore>,
-        #[allow(dead_code)] Subscription,
-    ),
+    Local(Entity<LocalToolchainStore>),
+    Remote(Entity<RemoteToolchainStore>),
 }
 
+pub struct Toolchains {
+    /// Auto-detected toolchains.
+    pub toolchains: ToolchainList,
+    /// Path of the project root at which we ran the automatic toolchain detection.
+    pub root_path: Arc<Path>,
+    pub user_toolchains: BTreeMap<ToolchainScope, IndexSet<Toolchain>>,
+}
 impl EventEmitter<ToolchainStoreEvent> for ToolchainStore {}
 impl ToolchainStore {
     pub fn init(client: &AnyProtoClient) {
         client.add_entity_request_handler(Self::handle_activate_toolchain);
         client.add_entity_request_handler(Self::handle_list_toolchains);
         client.add_entity_request_handler(Self::handle_active_toolchain);
+        client.add_entity_request_handler(Self::handle_resolve_toolchain);
     }
 
     pub fn local(
@@ -62,18 +72,26 @@ impl ToolchainStore {
             active_toolchains: Default::default(),
             manifest_tree,
         });
-        let subscription = cx.subscribe(&entity, |_, _, e: &ToolchainStoreEvent, cx| {
+        let _sub = cx.subscribe(&entity, |_, _, e: &ToolchainStoreEvent, cx| {
             cx.emit(e.clone())
         });
-        Self(ToolchainStoreInner::Local(entity, subscription))
+        Self {
+            mode: ToolchainStoreInner::Local(entity),
+            user_toolchains: Default::default(),
+            _sub,
+        }
     }
 
     pub(super) fn remote(project_id: u64, client: AnyProtoClient, cx: &mut Context<Self>) -> Self {
         let entity = cx.new(|_| RemoteToolchainStore { client, project_id });
-        let _subscription = cx.subscribe(&entity, |_, _, e: &ToolchainStoreEvent, cx| {
+        let _sub = cx.subscribe(&entity, |_, _, e: &ToolchainStoreEvent, cx| {
             cx.emit(e.clone())
         });
-        Self(ToolchainStoreInner::Remote(entity, _subscription))
+        Self {
+            mode: ToolchainStoreInner::Remote(entity),
+            user_toolchains: Default::default(),
+            _sub,
+        }
     }
     pub(crate) fn activate_toolchain(
         &self,
@@ -81,43 +99,130 @@ impl ToolchainStore {
         toolchain: Toolchain,
         cx: &mut App,
     ) -> Task<Option<()>> {
-        match &self.0 {
-            ToolchainStoreInner::Local(local, _) => {
+        match &self.mode {
+            ToolchainStoreInner::Local(local) => {
                 local.update(cx, |this, cx| this.activate_toolchain(path, toolchain, cx))
             }
-            ToolchainStoreInner::Remote(remote, _) => {
+            ToolchainStoreInner::Remote(remote) => {
                 remote.update(cx, |this, cx| this.activate_toolchain(path, toolchain, cx))
             }
         }
     }
+
+    pub(crate) fn user_toolchains(&self) -> BTreeMap<ToolchainScope, IndexSet<Toolchain>> {
+        self.user_toolchains.clone()
+    }
+    pub(crate) fn add_toolchain(
+        &mut self,
+        toolchain: Toolchain,
+        scope: ToolchainScope,
+        cx: &mut Context<Self>,
+    ) {
+        let did_insert = self
+            .user_toolchains
+            .entry(scope)
+            .or_default()
+            .insert(toolchain);
+        if did_insert {
+            cx.emit(ToolchainStoreEvent::CustomToolchainsModified);
+        }
+    }
+
+    pub(crate) fn remove_toolchain(
+        &mut self,
+        toolchain: Toolchain,
+        scope: ToolchainScope,
+        cx: &mut Context<Self>,
+    ) {
+        let mut did_remove = false;
+        self.user_toolchains
+            .entry(scope)
+            .and_modify(|toolchains| did_remove = toolchains.shift_remove(&toolchain));
+        if did_remove {
+            cx.emit(ToolchainStoreEvent::CustomToolchainsModified);
+        }
+    }
+
+    pub(crate) fn resolve_toolchain(
+        &self,
+        abs_path: PathBuf,
+        language_name: LanguageName,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<Toolchain>> {
+        debug_assert!(abs_path.is_absolute());
+        match &self.mode {
+            ToolchainStoreInner::Local(local) => local.update(cx, |this, cx| {
+                this.resolve_toolchain(abs_path, language_name, cx)
+            }),
+            ToolchainStoreInner::Remote(remote) => remote.update(cx, |this, cx| {
+                this.resolve_toolchain(abs_path, language_name, cx)
+            }),
+        }
+    }
     pub(crate) fn list_toolchains(
         &self,
         path: ProjectPath,
         language_name: LanguageName,
         cx: &mut Context<Self>,
-    ) -> Task<Option<(ToolchainList, Arc<Path>)>> {
-        match &self.0 {
-            ToolchainStoreInner::Local(local, _) => {
+    ) -> Task<Option<Toolchains>> {
+        let user_toolchains = self
+            .user_toolchains
+            .iter()
+            .filter(|(scope, _)| {
+                if let ToolchainScope::Subproject(worktree_id, relative_path) = scope {
+                    path.worktree_id == *worktree_id && relative_path.starts_with(&path.path)
+                } else {
+                    true
+                }
+            })
+            .map(|(scope, toolchains)| {
+                (
+                    scope.clone(),
+                    toolchains
+                        .iter()
+                        .filter(|toolchain| toolchain.language_name == language_name)
+                        .cloned()
+                        .collect::<IndexSet<_>>(),
+                )
+            })
+            .collect::<BTreeMap<_, _>>();
+        let task = match &self.mode {
+            ToolchainStoreInner::Local(local) => {
                 local.update(cx, |this, cx| this.list_toolchains(path, language_name, cx))
             }
-            ToolchainStoreInner::Remote(remote, _) => {
+            ToolchainStoreInner::Remote(remote) => {
                 remote.read(cx).list_toolchains(path, language_name, cx)
             }
-        }
+        };
+        cx.spawn(async move |_, _| {
+            let (mut toolchains, root_path) = task.await?;
+            toolchains.toolchains.retain(|toolchain| {
+                !user_toolchains
+                    .values()
+                    .any(|toolchains| toolchains.contains(toolchain))
+            });
+
+            Some(Toolchains {
+                toolchains,
+                root_path,
+                user_toolchains,
+            })
+        })
     }
+
     pub(crate) fn active_toolchain(
         &self,
         path: ProjectPath,
         language_name: LanguageName,
         cx: &App,
     ) -> Task<Option<Toolchain>> {
-        match &self.0 {
-            ToolchainStoreInner::Local(local, _) => Task::ready(local.read(cx).active_toolchain(
+        match &self.mode {
+            ToolchainStoreInner::Local(local) => Task::ready(local.read(cx).active_toolchain(
                 path.worktree_id,
                 &path.path,
                 language_name,
             )),
-            ToolchainStoreInner::Remote(remote, _) => {
+            ToolchainStoreInner::Remote(remote) => {
                 remote.read(cx).active_toolchain(path, language_name, cx)
             }
         }
@@ -197,7 +302,7 @@ impl ToolchainStore {
             })?
             .await;
         let has_values = toolchains.is_some();
-        let groups = if let Some((toolchains, _)) = &toolchains {
+        let groups = if let Some(Toolchains { toolchains, .. }) = &toolchains {
             toolchains
                 .groups
                 .iter()
@@ -211,7 +316,12 @@ impl ToolchainStore {
         } else {
             vec![]
         };
-        let (toolchains, relative_path) = if let Some((toolchains, relative_path)) = toolchains {
+        let (toolchains, relative_path) = if let Some(Toolchains {
+            toolchains,
+            root_path: relative_path,
+            ..
+        }) = toolchains
+        {
             let toolchains = toolchains
                 .toolchains
                 .into_iter()
@@ -236,16 +346,45 @@ impl ToolchainStore {
             relative_worktree_path: Some(relative_path.to_string_lossy().into_owned()),
         })
     }
+
+    async fn handle_resolve_toolchain(
+        this: Entity<Self>,
+        envelope: TypedEnvelope<proto::ResolveToolchain>,
+        mut cx: AsyncApp,
+    ) -> Result<proto::ResolveToolchainResponse> {
+        let toolchain = this
+            .update(&mut cx, |this, cx| {
+                let language_name = LanguageName::from_proto(envelope.payload.language_name);
+                let path = PathBuf::from(envelope.payload.abs_path);
+                this.resolve_toolchain(path, language_name, cx)
+            })?
+            .await;
+        let response = match toolchain {
+            Ok(toolchain) => {
+                let toolchain = proto::Toolchain {
+                    name: toolchain.name.to_string(),
+                    path: toolchain.path.to_string(),
+                    raw_json: toolchain.as_json.to_string(),
+                };
+                ResolveResponsePayload::Toolchain(toolchain)
+            }
+            Err(e) => ResolveResponsePayload::Error(e.to_string()),
+        };
+        Ok(ResolveToolchainResponse {
+            response: Some(response),
+        })
+    }
+
     pub fn as_language_toolchain_store(&self) -> Arc<dyn LanguageToolchainStore> {
-        match &self.0 {
-            ToolchainStoreInner::Local(local, _) => Arc::new(LocalStore(local.downgrade())),
-            ToolchainStoreInner::Remote(remote, _) => Arc::new(RemoteStore(remote.downgrade())),
+        match &self.mode {
+            ToolchainStoreInner::Local(local) => Arc::new(LocalStore(local.downgrade())),
+            ToolchainStoreInner::Remote(remote) => Arc::new(RemoteStore(remote.downgrade())),
         }
     }
     pub fn as_local_store(&self) -> Option<&Entity<LocalToolchainStore>> {
-        match &self.0 {
-            ToolchainStoreInner::Local(local, _) => Some(local),
-            ToolchainStoreInner::Remote(_, _) => None,
+        match &self.mode {
+            ToolchainStoreInner::Local(local) => Some(local),
+            ToolchainStoreInner::Remote(_) => None,
         }
     }
 }
@@ -311,6 +450,7 @@ struct RemoteStore(WeakEntity<RemoteToolchainStore>);
 #[derive(Clone)]
 pub enum ToolchainStoreEvent {
     ToolchainActivated,
+    CustomToolchainsModified,
 }
 
 impl EventEmitter<ToolchainStoreEvent> for LocalToolchainStore {}
@@ -351,7 +491,7 @@ impl LocalToolchainStore {
                 .await
                 .ok()?;
             let toolchains = language.toolchain_lister()?;
-            let manifest_name = toolchains.manifest_name();
+            let manifest_name = toolchains.meta().manifest_name;
             let (snapshot, worktree) = this
                 .update(cx, |this, cx| {
                     this.worktree_store
@@ -414,6 +554,33 @@ impl LocalToolchainStore {
             })
             .cloned()
     }
+
+    fn resolve_toolchain(
+        &self,
+        path: PathBuf,
+        language_name: LanguageName,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<Toolchain>> {
+        let registry = self.languages.clone();
+        let environment = self.project_environment.clone();
+        cx.spawn(async move |_, cx| {
+            let language = cx
+                .background_spawn(registry.language_for_name(&language_name.0))
+                .await
+                .with_context(|| format!("Language {} not found", language_name.0))?;
+            let toolchain_lister = language.toolchain_lister().with_context(|| {
+                format!("Language {} does not support toolchains", language_name.0)
+            })?;
+
+            let project_env = environment
+                .update(cx, |environment, cx| {
+                    environment.get_directory_environment(path.as_path().into(), cx)
+                })?
+                .await;
+            cx.background_spawn(async move { toolchain_lister.resolve(path, project_env).await })
+                .await
+        })
+    }
 }
 
 impl EventEmitter<ToolchainStoreEvent> for RemoteToolchainStore {}
@@ -556,4 +723,47 @@ impl RemoteToolchainStore {
             })
         })
     }
+
+    fn resolve_toolchain(
+        &self,
+        abs_path: PathBuf,
+        language_name: LanguageName,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<Toolchain>> {
+        let project_id = self.project_id;
+        let client = self.client.clone();
+        cx.background_spawn(async move {
+            let response: proto::ResolveToolchainResponse = client
+                .request(proto::ResolveToolchain {
+                    project_id,
+                    language_name: language_name.clone().into(),
+                    abs_path: abs_path.to_string_lossy().into_owned(),
+                })
+                .await?;
+
+            let response = response
+                .response
+                .context("Failed to resolve toolchain via RPC")?;
+            use proto::resolve_toolchain_response::Response;
+            match response {
+                Response::Toolchain(toolchain) => {
+                    Ok(Toolchain {
+                        language_name: language_name.clone(),
+                        name: toolchain.name.into(),
+                        // todo(windows)
+                        // Do we need to convert path to native string?
+                        path: PathBuf::from_proto(toolchain.path)
+                            .to_string_lossy()
+                            .to_string()
+                            .into(),
+                        as_json: serde_json::Value::from_str(&toolchain.raw_json)
+                            .context("Deserializing ResolveToolchain LSP response")?,
+                    })
+                }
+                Response::Error(error) => {
+                    anyhow::bail!("{error}");
+                }
+            }
+        })
+    }
 }
diff --git a/crates/project/src/worktree_store.rs b/crates/project/src/worktree_store.rs
index 1eeeefc40ad09012e5d280c0821052cd6f8db098..b37e1ef8026b643444b3ca0ba67cdb953a959a36 100644
--- a/crates/project/src/worktree_store.rs
+++ b/crates/project/src/worktree_store.rs
@@ -203,11 +203,10 @@ impl WorktreeStore {
         })
     }
 
-    pub fn entry_for_path(&self, path: &ProjectPath, cx: &App) -> Option<Entry> {
+    pub fn entry_for_path<'a>(&'a self, path: &ProjectPath, cx: &'a App) -> Option<&'a Entry> {
         self.worktree_for_id(path.worktree_id, cx)?
             .read(cx)
             .entry_for_path(&path.path)
-            .cloned()
     }
 
     pub fn create_worktree(
diff --git a/crates/project_panel/src/project_panel_settings.rs b/crates/project_panel/src/project_panel_settings.rs
index db9b2b85d545e85a0cff3ec13a8f75e28dac88fa..6c812c294663d1d6fe7915d201f9e8925fa943ab 100644
--- a/crates/project_panel/src/project_panel_settings.rs
+++ b/crates/project_panel/src/project_panel_settings.rs
@@ -2,7 +2,7 @@ use editor::ShowScrollbar;
 use gpui::Pixels;
 use schemars::JsonSchema;
 use serde_derive::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, Copy, PartialEq)]
 #[serde(rename_all = "snake_case")]
@@ -92,7 +92,8 @@ pub enum ShowDiagnostics {
     All,
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi, SettingsKey)]
+#[settings_key(key = "project_panel")]
 pub struct ProjectPanelSettingsContent {
     /// Whether to show the project panel button in the status bar.
     ///
@@ -168,8 +169,6 @@ pub struct ProjectPanelSettingsContent {
 }
 
 impl Settings for ProjectPanelSettings {
-    const KEY: Option<&'static str> = Some("project_panel");
-
     type FileContent = ProjectPanelSettingsContent;
 
     fn load(
diff --git a/crates/proto/proto/ai.proto b/crates/proto/proto/ai.proto
index 1064ed2f8d301a6cc80170ce33fcca33310c2f1d..9b4cc27dcb9755f5205907cc5fd93687aa76bc4f 100644
--- a/crates/proto/proto/ai.proto
+++ b/crates/proto/proto/ai.proto
@@ -2,6 +2,7 @@ syntax = "proto3";
 package zed.messages;
 
 import "buffer.proto";
+import "task.proto";
 
 message Context {
     repeated ContextOperation operations = 1;
@@ -164,3 +165,35 @@ enum LanguageModelRole {
     LanguageModelSystem = 2;
     reserved 3;
 }
+
+message GetAgentServerCommand {
+    uint64 project_id = 1;
+    string name = 2;
+    optional string root_dir = 3;
+}
+
+message AgentServerCommand {
+    string path = 1;
+    repeated string args = 2;
+    map<string, string> env = 3;
+    string root_dir = 4;
+
+    optional SpawnInTerminal login = 5;
+}
+
+message ExternalAgentsUpdated {
+    uint64 project_id = 1;
+    repeated string names = 2;
+}
+
+message ExternalAgentLoadingStatusUpdated {
+    uint64 project_id = 1;
+    string name = 2;
+    string status = 3;
+}
+
+message NewExternalAgentVersionAvailable {
+    uint64 project_id = 1;
+    string name = 2;
+    string version = 3;
+}
diff --git a/crates/proto/proto/buffer.proto b/crates/proto/proto/buffer.proto
index f4dacf2fdca97bf9766c8de348a67cd18f8fb973..4580fd8e9db80e7dc54b1c997f8df108e3bf9330 100644
--- a/crates/proto/proto/buffer.proto
+++ b/crates/proto/proto/buffer.proto
@@ -143,6 +143,7 @@ message Operation {
         UpdateSelections update_selections = 3;
         UpdateDiagnostics update_diagnostics = 4;
         UpdateCompletionTriggers update_completion_triggers = 5;
+        UpdateLineEnding update_line_ending = 6;
     }
 
     message Edit {
@@ -174,6 +175,12 @@ message Operation {
         repeated string triggers = 3;
         uint64 language_server_id = 4;
     }
+
+    message UpdateLineEnding {
+        uint32 replica_id = 1;
+        uint32 lamport_timestamp = 2;
+        LineEnding line_ending = 3;
+    }
 }
 
 message ProjectTransaction {
diff --git a/crates/proto/proto/channel.proto b/crates/proto/proto/channel.proto
index 324380048a4b649257b4cb2511612abf0fdd9f96..cada21cd5b7ede4730f2f4e71e98fb9a3dc12ff0 100644
--- a/crates/proto/proto/channel.proto
+++ b/crates/proto/proto/channel.proto
@@ -23,16 +23,17 @@ message UpdateChannels {
     repeated Channel channel_invitations = 5;
     repeated uint64 remove_channel_invitations = 6;
     repeated ChannelParticipants channel_participants = 7;
-    repeated ChannelMessageId latest_channel_message_ids = 8;
     repeated ChannelBufferVersion latest_channel_buffer_versions = 9;
 
+    reserved 8;
     reserved 10 to 15;
 }
 
 message UpdateUserChannels {
-    repeated ChannelMessageId observed_channel_message_id = 1;
     repeated ChannelBufferVersion observed_channel_buffer_version = 2;
     repeated ChannelMembership channel_memberships = 3;
+
+    reserved 1;
 }
 
 message ChannelMembership {
diff --git a/crates/proto/proto/debugger.proto b/crates/proto/proto/debugger.proto
index c6f9c9f1342336c36ab8dfd0ec70a24ff6564476..dcfb91c77dd0004bfb248d4e4c23dcf269b7bc11 100644
--- a/crates/proto/proto/debugger.proto
+++ b/crates/proto/proto/debugger.proto
@@ -3,6 +3,7 @@ package zed.messages;
 
 import "core.proto";
 import "buffer.proto";
+import "task.proto";
 
 enum BreakpointState {
     Enabled = 0;
@@ -533,16 +534,22 @@ message DebugScenario {
     optional string configuration = 7;
 }
 
-message SpawnInTerminal {
-    string label = 1;
-    optional string command = 2;
-    repeated string args = 3;
-    map<string, string> env = 4;
-    optional string cwd = 5;
-}
-
 message LogToDebugConsole {
     uint64 project_id = 1;
     uint64 session_id = 2;
     string message = 3;
 }
+
+message GetProcesses {
+    uint64 project_id = 1;
+}
+
+message GetProcessesResponse {
+    repeated ProcessInfo processes = 1;
+}
+
+message ProcessInfo {
+    uint32 pid = 1;
+    string name = 2;
+    repeated string command = 3;
+}
diff --git a/crates/proto/proto/task.proto b/crates/proto/proto/task.proto
index e6fa192ab5836371c5a2f1fb992b4b07f843655b..8fc3a6d18e1398d8647ba3daaa419829177e55f8 100644
--- a/crates/proto/proto/task.proto
+++ b/crates/proto/proto/task.proto
@@ -40,3 +40,11 @@ enum HideStrategy {
     HideNever = 1;
     HideOnSuccess = 2;
 }
+
+message SpawnInTerminal {
+    string label = 1;
+    optional string command = 2;
+    repeated string args = 3;
+    map<string, string> env = 4;
+    optional string cwd = 5;
+}
diff --git a/crates/proto/proto/toolchain.proto b/crates/proto/proto/toolchain.proto
index 08844a307a2c44cf2a30405b3202f10c72db579d..b190322ca0602078ea28d00fe970e4958fb17fb0 100644
--- a/crates/proto/proto/toolchain.proto
+++ b/crates/proto/proto/toolchain.proto
@@ -44,3 +44,16 @@ message ActiveToolchain {
 message ActiveToolchainResponse {
     optional Toolchain toolchain = 1;
 }
+
+message ResolveToolchain {
+    uint64 project_id = 1;
+    string abs_path = 2;
+    string language_name = 3;
+}
+
+message ResolveToolchainResponse {
+    oneof response {
+        Toolchain toolchain = 1;
+        string error = 2;
+    }
+}
diff --git a/crates/proto/proto/worktree.proto b/crates/proto/proto/worktree.proto
index 67bd1925b509c6fc7727fa5cf6338e6cc00a4ae0..19a61cc4bc8d3b04103afe3a6c6b799ab92461e3 100644
--- a/crates/proto/proto/worktree.proto
+++ b/crates/proto/proto/worktree.proto
@@ -150,3 +150,8 @@ enum LocalSettingsKind {
     Editorconfig = 2;
     Debug = 3;
 }
+
+message UpdateUserSettings {
+    uint64 project_id = 1;
+    string contents = 2;
+}
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index 2222bdec082759cb75ffcdb2c7a95435f36eba11..3286b9e752597a56cf39f24557a869a3f6fb5ffe 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -397,7 +397,23 @@ message Envelope {
 
         LspQuery lsp_query = 365;
         LspQueryResponse lsp_query_response = 366;
-        ToggleLspLogs toggle_lsp_logs = 367; // current max
+        ToggleLspLogs toggle_lsp_logs = 367;
+
+        UpdateUserSettings update_user_settings = 368;
+
+        GetProcesses get_processes = 369;
+        GetProcessesResponse get_processes_response = 370;
+
+        ResolveToolchain resolve_toolchain = 371;
+        ResolveToolchainResponse resolve_toolchain_response = 372;
+
+        GetAgentServerCommand get_agent_server_command = 373;
+        AgentServerCommand agent_server_command = 374;
+
+        ExternalAgentsUpdated external_agents_updated = 375;
+
+        ExternalAgentLoadingStatusUpdated external_agent_loading_status_updated = 376;
+        NewExternalAgentVersionAvailable new_external_agent_version_available = 377; // current max
     }
 
     reserved 87 to 88;
diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rs
index 04495fb898b1d9bdbf229bb69e1e44b8afa6d1fb..79e6b414ef516372eca3ec06b72de507ee2b8711 100644
--- a/crates/proto/src/proto.rs
+++ b/crates/proto/src/proto.rs
@@ -26,6 +26,8 @@ messages!(
     (ActivateToolchain, Foreground),
     (ActiveToolchain, Foreground),
     (ActiveToolchainResponse, Foreground),
+    (ResolveToolchain, Background),
+    (ResolveToolchainResponse, Background),
     (AddNotification, Foreground),
     (AddProjectCollaborator, Foreground),
     (AddWorktree, Foreground),
@@ -102,6 +104,8 @@ messages!(
     (GetPathMetadata, Background),
     (GetPathMetadataResponse, Background),
     (GetPermalinkToLine, Foreground),
+    (GetProcesses, Background),
+    (GetProcessesResponse, Background),
     (GetPermalinkToLineResponse, Foreground),
     (GetProjectSymbols, Background),
     (GetProjectSymbolsResponse, Background),
@@ -278,6 +282,7 @@ messages!(
     (UpdateUserChannels, Foreground),
     (UpdateWorktree, Foreground),
     (UpdateWorktreeSettings, Foreground),
+    (UpdateUserSettings, Background),
     (UpdateRepository, Foreground),
     (RemoveRepository, Foreground),
     (UsersResponse, Foreground),
@@ -314,6 +319,11 @@ messages!(
     (GitClone, Background),
     (GitCloneResponse, Background),
     (ToggleLspLogs, Background),
+    (GetAgentServerCommand, Background),
+    (AgentServerCommand, Background),
+    (ExternalAgentsUpdated, Background),
+    (ExternalAgentLoadingStatusUpdated, Background),
+    (NewExternalAgentVersionAvailable, Background),
 );
 
 request_messages!(
@@ -456,6 +466,7 @@ request_messages!(
     (ListToolchains, ListToolchainsResponse),
     (ActivateToolchain, Ack),
     (ActiveToolchain, ActiveToolchainResponse),
+    (ResolveToolchain, ResolveToolchainResponse),
     (GetPathMetadata, GetPathMetadataResponse),
     (GetCrashFiles, GetCrashFilesResponse),
     (CancelLanguageServerWork, Ack),
@@ -484,6 +495,8 @@ request_messages!(
     (GetDefaultBranch, GetDefaultBranchResponse),
     (GitClone, GitCloneResponse),
     (ToggleLspLogs, Ack),
+    (GetProcesses, GetProcessesResponse),
+    (GetAgentServerCommand, AgentServerCommand)
 );
 
 lsp_messages!(
@@ -583,6 +596,7 @@ entity_messages!(
     UpdateRepository,
     RemoveRepository,
     UpdateWorktreeSettings,
+    UpdateUserSettings,
     LspExtExpandMacro,
     LspExtOpenDocs,
     LspExtRunnables,
@@ -607,7 +621,9 @@ entity_messages!(
     ListToolchains,
     ActivateToolchain,
     ActiveToolchain,
+    ResolveToolchain,
     GetPathMetadata,
+    GetProcesses,
     CancelLanguageServerWork,
     RegisterBufferWithLanguageServers,
     GitShow,
@@ -634,7 +650,11 @@ entity_messages!(
     GetDocumentDiagnostics,
     PullWorkspaceDiagnostics,
     GetDefaultBranch,
-    GitClone
+    GitClone,
+    GetAgentServerCommand,
+    ExternalAgentsUpdated,
+    ExternalAgentLoadingStatusUpdated,
+    NewExternalAgentVersionAvailable,
 );
 
 entity_messages!(
diff --git a/crates/recent_projects/src/remote_connections.rs b/crates/recent_projects/src/remote_connections.rs
index a7f915301f42850b03be951f596a8542842a6877..3e6810239c80c72d74624bcc243157290fcd93fa 100644
--- a/crates/recent_projects/src/remote_connections.rs
+++ b/crates/recent_projects/src/remote_connections.rs
@@ -21,7 +21,7 @@ use remote::{
 };
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 use theme::ThemeSettings;
 use ui::{
     ActiveTheme, Color, CommonAnimationExt, Context, Icon, IconName, IconSize, InteractiveElement,
@@ -121,15 +121,14 @@ pub struct SshProject {
     pub paths: Vec<String>,
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey)]
+#[settings_key(None)]
 pub struct RemoteSettingsContent {
     pub ssh_connections: Option<Vec<SshConnection>>,
     pub read_ssh_config: Option<bool>,
 }
 
 impl Settings for SshSettings {
-    const KEY: Option<&'static str> = None;
-
     type FileContent = RemoteSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index f55826631b46b4f9eaaa17d8a9f4b0603a07fcc3..bdfd46002e63069b68b5661f1733060818a291e7 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -12,6 +12,7 @@ use node_runtime::NodeRuntime;
 use project::{
     LspStore, LspStoreEvent, ManifestTree, PrettierStore, ProjectEnvironment, ProjectPath,
     ToolchainStore, WorktreeId,
+    agent_server_store::AgentServerStore,
     buffer_store::{BufferStore, BufferStoreEvent},
     debugger::{breakpoint_store::BreakpointStore, dap_store::DapStore},
     git_store::GitStore,
@@ -32,6 +33,7 @@ use std::{
     path::{Path, PathBuf},
     sync::{Arc, atomic::AtomicUsize},
 };
+use sysinfo::System;
 use util::ResultExt;
 use worktree::Worktree;
 
@@ -43,6 +45,7 @@ pub struct HeadlessProject {
     pub lsp_store: Entity<LspStore>,
     pub task_store: Entity<TaskStore>,
     pub dap_store: Entity<DapStore>,
+    pub agent_server_store: Entity<AgentServerStore>,
     pub settings_observer: Entity<SettingsObserver>,
     pub next_entry_id: Arc<AtomicUsize>,
     pub languages: Arc<LanguageRegistry>,
@@ -181,7 +184,7 @@ impl HeadlessProject {
                     .as_local_store()
                     .expect("Toolchain store to be local")
                     .clone(),
-                environment,
+                environment.clone(),
                 manifest_tree,
                 languages.clone(),
                 http_client.clone(),
@@ -192,6 +195,13 @@ impl HeadlessProject {
             lsp_store
         });
 
+        let agent_server_store = cx.new(|cx| {
+            let mut agent_server_store =
+                AgentServerStore::local(node_runtime.clone(), fs.clone(), environment, cx);
+            agent_server_store.shared(REMOTE_SERVER_PROJECT_ID, session.clone());
+            agent_server_store
+        });
+
         cx.subscribe(&lsp_store, Self::on_lsp_store_event).detach();
         language_extension::init(
             language_extension::LspAccess::ViaLspStore(lsp_store.clone()),
@@ -225,11 +235,13 @@ impl HeadlessProject {
         session.subscribe_to_entity(REMOTE_SERVER_PROJECT_ID, &dap_store);
         session.subscribe_to_entity(REMOTE_SERVER_PROJECT_ID, &settings_observer);
         session.subscribe_to_entity(REMOTE_SERVER_PROJECT_ID, &git_store);
+        session.subscribe_to_entity(REMOTE_SERVER_PROJECT_ID, &agent_server_store);
 
         session.add_request_handler(cx.weak_entity(), Self::handle_list_remote_directory);
         session.add_request_handler(cx.weak_entity(), Self::handle_get_path_metadata);
         session.add_request_handler(cx.weak_entity(), Self::handle_shutdown_remote_server);
         session.add_request_handler(cx.weak_entity(), Self::handle_ping);
+        session.add_request_handler(cx.weak_entity(), Self::handle_get_processes);
 
         session.add_entity_request_handler(Self::handle_add_worktree);
         session.add_request_handler(cx.weak_entity(), Self::handle_remove_worktree);
@@ -262,6 +274,7 @@ impl HeadlessProject {
         // todo(debugger): Re init breakpoint store when we set it up for collab
         // BreakpointStore::init(&client);
         GitStore::init(&session);
+        AgentServerStore::init_headless(&session);
 
         HeadlessProject {
             next_entry_id: Default::default(),
@@ -273,6 +286,7 @@ impl HeadlessProject {
             lsp_store,
             task_store,
             dap_store,
+            agent_server_store,
             languages,
             extensions,
             git_store,
@@ -515,7 +529,7 @@ impl HeadlessProject {
             let buffer_store = this.buffer_store.clone();
             let buffer = this
                 .buffer_store
-                .update(cx, |buffer_store, cx| buffer_store.create_buffer(cx));
+                .update(cx, |buffer_store, cx| buffer_store.create_buffer(true, cx));
             anyhow::Ok((buffer_store, buffer))
         })??;
 
@@ -719,6 +733,34 @@ impl HeadlessProject {
         log::debug!("Received ping from client");
         Ok(proto::Ack {})
     }
+
+    async fn handle_get_processes(
+        _this: Entity<Self>,
+        _envelope: TypedEnvelope<proto::GetProcesses>,
+        _cx: AsyncApp,
+    ) -> Result<proto::GetProcessesResponse> {
+        let mut processes = Vec::new();
+        let system = System::new_all();
+
+        for (_pid, process) in system.processes() {
+            let name = process.name().to_string_lossy().into_owned();
+            let command = process
+                .cmd()
+                .iter()
+                .map(|s| s.to_string_lossy().to_string())
+                .collect::<Vec<_>>();
+
+            processes.push(proto::ProcessInfo {
+                pid: process.pid().as_u32(),
+                name,
+                command,
+            });
+        }
+
+        processes.sort_by_key(|p| p.name.clone());
+
+        Ok(proto::GetProcessesResponse { processes })
+    }
 }
 
 fn prompt_to_proto(
diff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rs
index 353857f5871551a20315f638aa3d9653b3ed2848..c0ccaf900d18ee176bab7193c2bfb65b8555318d 100644
--- a/crates/remote_server/src/remote_editing_tests.rs
+++ b/crates/remote_server/src/remote_editing_tests.rs
@@ -280,7 +280,8 @@ async fn test_remote_settings(cx: &mut TestAppContext, server_cx: &mut TestAppCo
             AllLanguageSettings::get_global(cx)
                 .language(None, Some(&"Rust".into()), cx)
                 .language_servers,
-            ["..."] // local settings are ignored
+            ["from-local-settings"],
+            "User language settings should be synchronized with the server settings"
         )
     });
 
@@ -300,7 +301,8 @@ async fn test_remote_settings(cx: &mut TestAppContext, server_cx: &mut TestAppCo
             AllLanguageSettings::get_global(cx)
                 .language(None, Some(&"Rust".into()), cx)
                 .language_servers,
-            ["from-server-settings".to_string()]
+            ["from-server-settings".to_string()],
+            "Server language settings should take precedence over the user settings"
         )
     });
 
diff --git a/crates/remote_server/src/unix.rs b/crates/remote_server/src/unix.rs
index cb671a72d9beab0983536571e81fcd78f3df21c8..4aef536f0a45b5ea943f861da2be94ab7c2c21c4 100644
--- a/crates/remote_server/src/unix.rs
+++ b/crates/remote_server/src/unix.rs
@@ -918,29 +918,33 @@ fn initialize_settings(
     });
 
     let (mut tx, rx) = watch::channel(None);
+    let mut node_settings = None;
     cx.observe_global::<SettingsStore>(move |cx| {
-        let settings = &ProjectSettings::get_global(cx).node;
-        log::info!("Got new node settings: {:?}", settings);
-        let options = NodeBinaryOptions {
-            allow_path_lookup: !settings.ignore_system_version,
-            // TODO: Implement this setting
-            allow_binary_download: true,
-            use_paths: settings.path.as_ref().map(|node_path| {
-                let node_path = PathBuf::from(shellexpand::tilde(node_path).as_ref());
-                let npm_path = settings
-                    .npm_path
-                    .as_ref()
-                    .map(|path| PathBuf::from(shellexpand::tilde(&path).as_ref()));
-                (
-                    node_path.clone(),
-                    npm_path.unwrap_or_else(|| {
-                        let base_path = PathBuf::new();
-                        node_path.parent().unwrap_or(&base_path).join("npm")
-                    }),
-                )
-            }),
-        };
-        tx.send(Some(options)).log_err();
+        let new_node_settings = &ProjectSettings::get_global(cx).node;
+        if Some(new_node_settings) != node_settings.as_ref() {
+            log::info!("Got new node settings: {new_node_settings:?}");
+            let options = NodeBinaryOptions {
+                allow_path_lookup: !new_node_settings.ignore_system_version,
+                // TODO: Implement this setting
+                allow_binary_download: true,
+                use_paths: new_node_settings.path.as_ref().map(|node_path| {
+                    let node_path = PathBuf::from(shellexpand::tilde(node_path).as_ref());
+                    let npm_path = new_node_settings
+                        .npm_path
+                        .as_ref()
+                        .map(|path| PathBuf::from(shellexpand::tilde(&path).as_ref()));
+                    (
+                        node_path.clone(),
+                        npm_path.unwrap_or_else(|| {
+                            let base_path = PathBuf::new();
+                            node_path.parent().unwrap_or(&base_path).join("npm")
+                        }),
+                    )
+                }),
+            };
+            node_settings = Some(new_node_settings.clone());
+            tx.send(Some(options)).ok();
+        }
     })
     .detach();
 
diff --git a/crates/repl/src/jupyter_settings.rs b/crates/repl/src/jupyter_settings.rs
index 6f3d6b1db631267e9b41ae7598d6e573387f2ac6..c89736a03dc6d77dd89bb33c4990b25149189a41 100644
--- a/crates/repl/src/jupyter_settings.rs
+++ b/crates/repl/src/jupyter_settings.rs
@@ -4,7 +4,7 @@ use editor::EditorSettings;
 use gpui::App;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 
 #[derive(Debug, Default)]
 pub struct JupyterSettings {
@@ -20,7 +20,8 @@ impl JupyterSettings {
     }
 }
 
-#[derive(Clone, Serialize, Deserialize, JsonSchema, Debug, SettingsUi)]
+#[derive(Clone, Serialize, Deserialize, JsonSchema, Debug, SettingsUi, SettingsKey)]
+#[settings_key(key = "jupyter")]
 pub struct JupyterSettingsContent {
     /// Default kernels to select for each language.
     ///
@@ -37,8 +38,6 @@ impl Default for JupyterSettingsContent {
 }
 
 impl Settings for JupyterSettings {
-    const KEY: Option<&'static str> = Some("jupyter");
-
     type FileContent = JupyterSettingsContent;
 
     fn load(
diff --git a/crates/repl/src/kernels/mod.rs b/crates/repl/src/kernels/mod.rs
index 52188a39c48f5fc07a1f4a64949a82d205f75f9f..fb16cb1ea3b093b0592cb114a1224dc4858630fe 100644
--- a/crates/repl/src/kernels/mod.rs
+++ b/crates/repl/src/kernels/mod.rs
@@ -11,7 +11,7 @@ use language::LanguageName;
 pub use native_kernel::*;
 
 mod remote_kernels;
-use project::{Project, ProjectPath, WorktreeId};
+use project::{Project, ProjectPath, Toolchains, WorktreeId};
 pub use remote_kernels::*;
 
 use anyhow::Result;
@@ -92,49 +92,58 @@ pub fn python_env_kernel_specifications(
     let background_executor = cx.background_executor().clone();
 
     async move {
-        let toolchains = if let Some((toolchains, _)) = toolchains.await {
-            toolchains
+        let (toolchains, user_toolchains) = if let Some(Toolchains {
+            toolchains,
+            root_path: _,
+            user_toolchains,
+        }) = toolchains.await
+        {
+            (toolchains, user_toolchains)
         } else {
             return Ok(Vec::new());
         };
 
-        let kernelspecs = toolchains.toolchains.into_iter().map(|toolchain| {
-            background_executor.spawn(async move {
-                let python_path = toolchain.path.to_string();
-
-                // Check if ipykernel is installed
-                let ipykernel_check = util::command::new_smol_command(&python_path)
-                    .args(&["-c", "import ipykernel"])
-                    .output()
-                    .await;
-
-                if ipykernel_check.is_ok() && ipykernel_check.unwrap().status.success() {
-                    // Create a default kernelspec for this environment
-                    let default_kernelspec = JupyterKernelspec {
-                        argv: vec![
-                            python_path.clone(),
-                            "-m".to_string(),
-                            "ipykernel_launcher".to_string(),
-                            "-f".to_string(),
-                            "{connection_file}".to_string(),
-                        ],
-                        display_name: toolchain.name.to_string(),
-                        language: "python".to_string(),
-                        interrupt_mode: None,
-                        metadata: None,
-                        env: None,
-                    };
-
-                    Some(KernelSpecification::PythonEnv(LocalKernelSpecification {
-                        name: toolchain.name.to_string(),
-                        path: PathBuf::from(&python_path),
-                        kernelspec: default_kernelspec,
-                    }))
-                } else {
-                    None
-                }
-            })
-        });
+        let kernelspecs = user_toolchains
+            .into_values()
+            .flatten()
+            .chain(toolchains.toolchains)
+            .map(|toolchain| {
+                background_executor.spawn(async move {
+                    let python_path = toolchain.path.to_string();
+
+                    // Check if ipykernel is installed
+                    let ipykernel_check = util::command::new_smol_command(&python_path)
+                        .args(&["-c", "import ipykernel"])
+                        .output()
+                        .await;
+
+                    if ipykernel_check.is_ok() && ipykernel_check.unwrap().status.success() {
+                        // Create a default kernelspec for this environment
+                        let default_kernelspec = JupyterKernelspec {
+                            argv: vec![
+                                python_path.clone(),
+                                "-m".to_string(),
+                                "ipykernel_launcher".to_string(),
+                                "-f".to_string(),
+                                "{connection_file}".to_string(),
+                            ],
+                            display_name: toolchain.name.to_string(),
+                            language: "python".to_string(),
+                            interrupt_mode: None,
+                            metadata: None,
+                            env: None,
+                        };
+
+                        Some(KernelSpecification::PythonEnv(LocalKernelSpecification {
+                            name: toolchain.name.to_string(),
+                            path: PathBuf::from(&python_path),
+                            kernelspec: default_kernelspec,
+                        }))
+                    } else {
+                        None
+                    }
+                })
+            });
 
         let kernel_specs = futures::future::join_all(kernelspecs)
             .await
diff --git a/crates/repl/src/notebook/notebook_ui.rs b/crates/repl/src/notebook/notebook_ui.rs
index 325d262d9eddc164093f088d0e4790d0fa581167..081c474cdad86a5340520ef09345bd456f55b5ba 100644
--- a/crates/repl/src/notebook/notebook_ui.rs
+++ b/crates/repl/src/notebook/notebook_ui.rs
@@ -594,9 +594,10 @@ impl project::ProjectItem for NotebookItem {
                 };
 
                 let id = project
-                    .update(cx, |project, cx| project.entry_for_path(&path, cx))?
-                    .context("Entry not found")?
-                    .id;
+                    .update(cx, |project, cx| {
+                        project.entry_for_path(&path, cx).map(|entry| entry.id)
+                    })?
+                    .context("Entry not found")?;
 
                 cx.new(|_| NotebookItem {
                     path: abs_path,
diff --git a/crates/rope/benches/rope_benchmark.rs b/crates/rope/benches/rope_benchmark.rs
index 2233708525a8a060c78e66340537317cc6694d18..cb741fc78481e7d03a7c18dbf0d8919359b06436 100644
--- a/crates/rope/benches/rope_benchmark.rs
+++ b/crates/rope/benches/rope_benchmark.rs
@@ -28,11 +28,11 @@ fn generate_random_rope_ranges(mut rng: StdRng, rope: &Rope) -> Vec<Range<usize>
     let mut start = 0;
     for _ in 0..num_ranges {
         let range_start = rope.clip_offset(
-            rng.gen_range(start..=(start + range_max_len)),
+            rng.random_range(start..=(start + range_max_len)),
             sum_tree::Bias::Left,
         );
         let range_end = rope.clip_offset(
-            rng.gen_range(range_start..(range_start + range_max_len)),
+            rng.random_range(range_start..(range_start + range_max_len)),
             sum_tree::Bias::Right,
         );
 
@@ -52,7 +52,7 @@ fn generate_random_rope_points(mut rng: StdRng, rope: &Rope) -> Vec<Point> {
 
     let mut points = Vec::new();
     for _ in 0..num_points {
-        points.push(rope.offset_to_point(rng.gen_range(0..rope.len())));
+        points.push(rope.offset_to_point(rng.random_range(0..rope.len())));
     }
     points
 }
diff --git a/crates/rope/src/chunk.rs b/crates/rope/src/chunk.rs
index 00679d8cf539af5759250dfe6fc7406e192407fb..689875274a460abafb808ab7db7db3f5e0487a03 100644
--- a/crates/rope/src/chunk.rs
+++ b/crates/rope/src/chunk.rs
@@ -612,7 +612,7 @@ mod tests {
 
     #[gpui::test(iterations = 100)]
     fn test_random_chunks(mut rng: StdRng) {
-        let chunk_len = rng.gen_range(0..=MAX_BASE);
+        let chunk_len = rng.random_range(0..=MAX_BASE);
         let text = RandomCharIter::new(&mut rng)
             .take(chunk_len)
             .collect::<String>();
@@ -627,8 +627,8 @@ mod tests {
         verify_chunk(chunk.as_slice(), text);
 
         for _ in 0..10 {
-            let mut start = rng.gen_range(0..=chunk.text.len());
-            let mut end = rng.gen_range(start..=chunk.text.len());
+            let mut start = rng.random_range(0..=chunk.text.len());
+            let mut end = rng.random_range(start..=chunk.text.len());
             while !chunk.text.is_char_boundary(start) {
                 start -= 1;
             }
@@ -645,7 +645,7 @@ mod tests {
 
     #[gpui::test(iterations = 1000)]
     fn test_nth_set_bit_random(mut rng: StdRng) {
-        let set_count = rng.gen_range(0..=128);
+        let set_count = rng.random_range(0..=128);
         let mut set_bits = (0..128).choose_multiple(&mut rng, set_count);
         set_bits.sort();
         let mut n = 0;
diff --git a/crates/rope/src/rope.rs b/crates/rope/src/rope.rs
index 41b2a2d033eb49a1851c02e7066be22d807bca4b..9185b5baa300af93ec7ceb3e951ae6ba71772721 100644
--- a/crates/rope/src/rope.rs
+++ b/crates/rope/src/rope.rs
@@ -639,18 +639,20 @@ impl<'a> Chunks<'a> {
     pub fn seek(&mut self, mut offset: usize) {
         offset = offset.clamp(self.range.start, self.range.end);
 
-        let bias = if self.reversed {
-            Bias::Left
+        if self.reversed {
+            if offset > self.chunks.end() {
+                self.chunks.seek_forward(&offset, Bias::Left);
+            } else if offset <= *self.chunks.start() {
+                self.chunks.seek(&offset, Bias::Left);
+            }
         } else {
-            Bias::Right
+            if offset >= self.chunks.end() {
+                self.chunks.seek_forward(&offset, Bias::Right);
+            } else if offset < *self.chunks.start() {
+                self.chunks.seek(&offset, Bias::Right);
+            }
         };
 
-        if offset >= self.chunks.end() {
-            self.chunks.seek_forward(&offset, bias);
-        } else {
-            self.chunks.seek(&offset, bias);
-        }
-
         self.offset = offset;
     }
 
@@ -1610,9 +1612,9 @@ mod tests {
         let mut expected = String::new();
         let mut actual = Rope::new();
         for _ in 0..operations {
-            let end_ix = clip_offset(&expected, rng.gen_range(0..=expected.len()), Right);
-            let start_ix = clip_offset(&expected, rng.gen_range(0..=end_ix), Left);
-            let len = rng.gen_range(0..=64);
+            let end_ix = clip_offset(&expected, rng.random_range(0..=expected.len()), Right);
+            let start_ix = clip_offset(&expected, rng.random_range(0..=end_ix), Left);
+            let len = rng.random_range(0..=64);
             let new_text: String = RandomCharIter::new(&mut rng).take(len).collect();
 
             let mut new_actual = Rope::new();
@@ -1629,8 +1631,8 @@ mod tests {
             log::info!("text: {:?}", expected);
 
             for _ in 0..5 {
-                let end_ix = clip_offset(&expected, rng.gen_range(0..=expected.len()), Right);
-                let start_ix = clip_offset(&expected, rng.gen_range(0..=end_ix), Left);
+                let end_ix = clip_offset(&expected, rng.random_range(0..=expected.len()), Right);
+                let start_ix = clip_offset(&expected, rng.random_range(0..=end_ix), Left);
 
                 let actual_text = actual.chunks_in_range(start_ix..end_ix).collect::<String>();
                 assert_eq!(actual_text, &expected[start_ix..end_ix]);
@@ -1695,14 +1697,14 @@ mod tests {
                 );
 
                 // Check that next_line/prev_line work correctly from random positions
-                let mut offset = rng.gen_range(start_ix..=end_ix);
+                let mut offset = rng.random_range(start_ix..=end_ix);
                 while !expected.is_char_boundary(offset) {
                     offset -= 1;
                 }
                 chunks.seek(offset);
 
                 for _ in 0..5 {
-                    if rng.r#gen() {
+                    if rng.random() {
                         let expected_next_line_start = expected[offset..end_ix]
                             .find('\n')
                             .map(|newline_ix| offset + newline_ix + 1);
@@ -1791,8 +1793,8 @@ mod tests {
                     }
 
                     assert!((start_ix..=end_ix).contains(&chunks.offset()));
-                    if rng.r#gen() {
-                        offset = rng.gen_range(start_ix..=end_ix);
+                    if rng.random() {
+                        offset = rng.random_range(start_ix..=end_ix);
                         while !expected.is_char_boundary(offset) {
                             offset -= 1;
                         }
@@ -1876,8 +1878,8 @@ mod tests {
             }
 
             for _ in 0..5 {
-                let end_ix = clip_offset(&expected, rng.gen_range(0..=expected.len()), Right);
-                let start_ix = clip_offset(&expected, rng.gen_range(0..=end_ix), Left);
+                let end_ix = clip_offset(&expected, rng.random_range(0..=expected.len()), Right);
+                let start_ix = clip_offset(&expected, rng.random_range(0..=end_ix), Left);
                 assert_eq!(
                     actual.cursor(start_ix).summary::<TextSummary>(end_ix),
                     TextSummary::from(&expected[start_ix..end_ix])
diff --git a/crates/rpc/src/auth.rs b/crates/rpc/src/auth.rs
index 2e3546289d6bbc476ea7dd6002cb70d466a53d3f..3829f3d36b7cbddd00678f815d08053c864c2010 100644
--- a/crates/rpc/src/auth.rs
+++ b/crates/rpc/src/auth.rs
@@ -1,6 +1,6 @@
 use anyhow::{Context as _, Result};
 use base64::prelude::*;
-use rand::{Rng as _, thread_rng};
+use rand::prelude::*;
 use rsa::pkcs1::{DecodeRsaPublicKey, EncodeRsaPublicKey};
 use rsa::traits::PaddingScheme;
 use rsa::{Oaep, Pkcs1v15Encrypt, RsaPrivateKey, RsaPublicKey};
@@ -31,7 +31,7 @@ pub struct PrivateKey(RsaPrivateKey);
 
 /// Generate a public and private key for asymmetric encryption.
 pub fn keypair() -> Result<(PublicKey, PrivateKey)> {
-    let mut rng = thread_rng();
+    let mut rng = RsaRngCompat::new();
     let bits = 2048;
     let private_key = RsaPrivateKey::new(&mut rng, bits)?;
     let public_key = RsaPublicKey::from(&private_key);
@@ -40,10 +40,10 @@ pub fn keypair() -> Result<(PublicKey, PrivateKey)> {
 
 /// Generate a random 64-character base64 string.
 pub fn random_token() -> String {
-    let mut rng = thread_rng();
+    let mut rng = rand::rng();
     let mut token_bytes = [0; 48];
     for byte in token_bytes.iter_mut() {
-        *byte = rng.r#gen();
+        *byte = rng.random();
     }
     BASE64_URL_SAFE.encode(token_bytes)
 }
@@ -52,7 +52,7 @@ impl PublicKey {
     /// Convert a string to a base64-encoded string that can only be decoded with the corresponding
     /// private key.
     pub fn encrypt_string(&self, string: &str, format: EncryptionFormat) -> Result<String> {
-        let mut rng = thread_rng();
+        let mut rng = RsaRngCompat::new();
         let bytes = string.as_bytes();
         let encrypted_bytes = match format {
             EncryptionFormat::V0 => self.0.encrypt(&mut rng, Pkcs1v15Encrypt, bytes),
@@ -107,6 +107,36 @@ impl TryFrom<String> for PublicKey {
     }
 }
 
+// TODO: remove once we rsa v0.10 is released.
+struct RsaRngCompat(rand::rngs::ThreadRng);
+
+impl RsaRngCompat {
+    fn new() -> Self {
+        Self(rand::rng())
+    }
+}
+
+impl rsa::signature::rand_core::RngCore for RsaRngCompat {
+    fn next_u32(&mut self) -> u32 {
+        self.0.next_u32()
+    }
+
+    fn next_u64(&mut self) -> u64 {
+        self.0.next_u64()
+    }
+
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        self.0.fill_bytes(dest);
+    }
+
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rsa::signature::rand_core::Error> {
+        self.fill_bytes(dest);
+        Ok(())
+    }
+}
+
+impl rsa::signature::rand_core::CryptoRng for RsaRngCompat {}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/rpc/src/notification.rs b/crates/rpc/src/notification.rs
index 338ef33c8abf7bc694a07ecacfbdb94711a6924b..50364c738798d21e8f66e37086bcaf309bdedfb0 100644
--- a/crates/rpc/src/notification.rs
+++ b/crates/rpc/src/notification.rs
@@ -32,12 +32,6 @@ pub enum Notification {
         channel_name: String,
         inviter_id: u64,
     },
-    ChannelMessageMention {
-        #[serde(rename = "entity_id")]
-        message_id: u64,
-        sender_id: u64,
-        channel_id: u64,
-    },
 }
 
 impl Notification {
@@ -91,11 +85,6 @@ mod tests {
                 channel_name: "the-channel".into(),
                 inviter_id: 50,
             },
-            Notification::ChannelMessageMention {
-                sender_id: 200,
-                channel_id: 30,
-                message_id: 1,
-            },
         ] {
             let message = notification.to_proto();
             let deserialized = Notification::from_proto(&message).unwrap();
diff --git a/crates/scheduler/Cargo.toml b/crates/scheduler/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0446c67914541964f01514865ddc363c60f837c8
--- /dev/null
+++ b/crates/scheduler/Cargo.toml
@@ -0,0 +1,25 @@
+[package]
+name = "scheduler"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "Apache-2.0"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/scheduler.rs"
+doctest = false
+
+[features]
+test-support = []
+
+[dependencies]
+async-task.workspace = true
+chrono.workspace = true
+futures.workspace = true
+parking.workspace = true
+parking_lot.workspace = true
+rand.workspace = true
+workspace-hack.workspace = true
diff --git a/extensions/toml/LICENSE-APACHE b/crates/scheduler/LICENSE-APACHE
similarity index 100%
rename from extensions/toml/LICENSE-APACHE
rename to crates/scheduler/LICENSE-APACHE
diff --git a/crates/scheduler/src/clock.rs b/crates/scheduler/src/clock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c035c6b7dbcbabeaeeb2a952974cc4bf777c1f92
--- /dev/null
+++ b/crates/scheduler/src/clock.rs
@@ -0,0 +1,34 @@
+use chrono::{DateTime, Duration, Utc};
+use parking_lot::Mutex;
+
+pub trait Clock {
+    fn now(&self) -> DateTime<Utc>;
+}
+
+pub struct TestClock {
+    now: Mutex<DateTime<Utc>>,
+}
+
+impl TestClock {
+    pub fn new() -> Self {
+        const START_TIME: &str = "2025-07-01T23:59:58-00:00";
+        let now = DateTime::parse_from_rfc3339(START_TIME).unwrap().to_utc();
+        Self {
+            now: Mutex::new(now),
+        }
+    }
+
+    pub fn set_now(&self, now: DateTime<Utc>) {
+        *self.now.lock() = now;
+    }
+
+    pub fn advance(&self, duration: Duration) {
+        *self.now.lock() += duration;
+    }
+}
+
+impl Clock for TestClock {
+    fn now(&self) -> DateTime<Utc> {
+        *self.now.lock()
+    }
+}
diff --git a/crates/scheduler/src/executor.rs b/crates/scheduler/src/executor.rs
new file mode 100644
index 0000000000000000000000000000000000000000..03f91ae551ff086f56e089bd53d690a2c5345949
--- /dev/null
+++ b/crates/scheduler/src/executor.rs
@@ -0,0 +1,137 @@
+use crate::{Scheduler, SessionId, Timer};
+use std::{
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+    rc::Rc,
+    sync::Arc,
+    task::{Context, Poll},
+    time::Duration,
+};
+
+#[derive(Clone)]
+pub struct ForegroundExecutor {
+    session_id: SessionId,
+    scheduler: Arc<dyn Scheduler>,
+    not_send: PhantomData<Rc<()>>,
+}
+
+impl ForegroundExecutor {
+    pub fn spawn<F>(&self, future: F) -> Task<F::Output>
+    where
+        F: Future + 'static,
+        F::Output: 'static,
+    {
+        let session_id = self.session_id;
+        let scheduler = Arc::clone(&self.scheduler);
+        let (runnable, task) = async_task::spawn_local(future, move |runnable| {
+            scheduler.schedule_foreground(session_id, runnable);
+        });
+        runnable.schedule();
+        Task(TaskState::Spawned(task))
+    }
+
+    pub fn timer(&self, duration: Duration) -> Timer {
+        self.scheduler.timer(duration)
+    }
+}
+
+impl ForegroundExecutor {
+    pub fn new(session_id: SessionId, scheduler: Arc<dyn Scheduler>) -> Self {
+        assert!(
+            scheduler.is_main_thread(),
+            "ForegroundExecutor must be created on the same thread as the Scheduler"
+        );
+        Self {
+            session_id,
+            scheduler,
+            not_send: PhantomData,
+        }
+    }
+}
+
+impl BackgroundExecutor {
+    pub fn new(scheduler: Arc<dyn Scheduler>) -> Self {
+        Self { scheduler }
+    }
+}
+
+pub struct BackgroundExecutor {
+    scheduler: Arc<dyn Scheduler>,
+}
+
+impl BackgroundExecutor {
+    pub fn spawn<F>(&self, future: F) -> Task<F::Output>
+    where
+        F: Future + Send + 'static,
+        F::Output: Send + 'static,
+    {
+        let scheduler = Arc::clone(&self.scheduler);
+        let (runnable, task) = async_task::spawn(future, move |runnable| {
+            scheduler.schedule_background(runnable);
+        });
+        runnable.schedule();
+        Task(TaskState::Spawned(task))
+    }
+
+    pub fn block_on<Fut: Future>(&self, future: Fut) -> Fut::Output {
+        self.scheduler.block_on(future)
+    }
+
+    pub fn block_with_timeout<Fut: Unpin + Future>(
+        &self,
+        future: &mut Fut,
+        timeout: Duration,
+    ) -> Option<Fut::Output> {
+        self.scheduler.block_with_timeout(future, timeout)
+    }
+
+    pub fn timer(&self, duration: Duration) -> Timer {
+        self.scheduler.timer(duration)
+    }
+}
+
+/// Task is a primitive that allows work to happen in the background.
+///
+/// It implements [`Future`] so you can `.await` on it.
+///
+/// If you drop a task it will be cancelled immediately. Calling [`Task::detach`] allows
+/// the task to continue running, but with no way to return a value.
+#[must_use]
+#[derive(Debug)]
+pub struct Task<T>(TaskState<T>);
+
+#[derive(Debug)]
+enum TaskState<T> {
+    /// A task that is ready to return a value
+    Ready(Option<T>),
+
+    /// A task that is currently running.
+    Spawned(async_task::Task<T>),
+}
+
+impl<T> Task<T> {
+    /// Creates a new task that will resolve with the value
+    pub fn ready(val: T) -> Self {
+        Task(TaskState::Ready(Some(val)))
+    }
+
+    /// Detaching a task runs it to completion in the background
+    pub fn detach(self) {
+        match self {
+            Task(TaskState::Ready(_)) => {}
+            Task(TaskState::Spawned(task)) => task.detach(),
+        }
+    }
+}
+
+impl<T> Future for Task<T> {
+    type Output = T;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+        match unsafe { self.get_unchecked_mut() } {
+            Task(TaskState::Ready(val)) => Poll::Ready(val.take().unwrap()),
+            Task(TaskState::Spawned(task)) => Pin::new(task).poll(cx),
+        }
+    }
+}
diff --git a/crates/scheduler/src/scheduler.rs b/crates/scheduler/src/scheduler.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ee1964784565266aba2fcc1efd1cd8de0a7fd5e7
--- /dev/null
+++ b/crates/scheduler/src/scheduler.rs
@@ -0,0 +1,63 @@
+mod clock;
+mod executor;
+mod test_scheduler;
+#[cfg(test)]
+mod tests;
+
+pub use clock::*;
+pub use executor::*;
+pub use test_scheduler::*;
+
+use async_task::Runnable;
+use futures::{FutureExt as _, channel::oneshot, future::LocalBoxFuture};
+use std::{
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll},
+    time::Duration,
+};
+
+pub trait Scheduler: Send + Sync {
+    fn block(&self, future: LocalBoxFuture<()>, timeout: Option<Duration>);
+    fn schedule_foreground(&self, session_id: SessionId, runnable: Runnable);
+    fn schedule_background(&self, runnable: Runnable);
+    fn timer(&self, timeout: Duration) -> Timer;
+    fn is_main_thread(&self) -> bool;
+}
+
+impl dyn Scheduler {
+    pub fn block_on<Fut: Future>(&self, future: Fut) -> Fut::Output {
+        let mut output = None;
+        self.block(async { output = Some(future.await) }.boxed_local(), None);
+        output.unwrap()
+    }
+
+    pub fn block_with_timeout<Fut: Unpin + Future>(
+        &self,
+        future: &mut Fut,
+        timeout: Duration,
+    ) -> Option<Fut::Output> {
+        let mut output = None;
+        self.block(
+            async { output = Some(future.await) }.boxed_local(),
+            Some(timeout),
+        );
+        output
+    }
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
+pub struct SessionId(u16);
+
+pub struct Timer(oneshot::Receiver<()>);
+
+impl Future for Timer {
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<()> {
+        match self.0.poll_unpin(cx) {
+            Poll::Ready(_) => Poll::Ready(()),
+            Poll::Pending => Poll::Pending,
+        }
+    }
+}
diff --git a/crates/scheduler/src/test_scheduler.rs b/crates/scheduler/src/test_scheduler.rs
new file mode 100644
index 0000000000000000000000000000000000000000..479759d9bdb775a3d2a71bae586fba9d658e71ce
--- /dev/null
+++ b/crates/scheduler/src/test_scheduler.rs
@@ -0,0 +1,352 @@
+use crate::{
+    BackgroundExecutor, Clock as _, ForegroundExecutor, Scheduler, SessionId, TestClock, Timer,
+};
+use async_task::Runnable;
+use chrono::{DateTime, Duration as ChronoDuration, Utc};
+use futures::{FutureExt as _, channel::oneshot, future::LocalBoxFuture};
+use parking_lot::Mutex;
+use rand::prelude::*;
+use std::{
+    collections::VecDeque,
+    future::Future,
+    panic::{self, AssertUnwindSafe},
+    pin::Pin,
+    sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering::SeqCst},
+    },
+    task::{Context, Poll, Wake, Waker},
+    thread,
+    time::{Duration, Instant},
+};
+
+pub struct TestScheduler {
+    clock: Arc<TestClock>,
+    rng: Arc<Mutex<StdRng>>,
+    state: Mutex<SchedulerState>,
+    pub thread_id: thread::ThreadId,
+    pub config: SchedulerConfig,
+}
+
+impl TestScheduler {
+    /// Run a test once with default configuration (seed 0)
+    pub fn once<R>(f: impl AsyncFnOnce(Arc<TestScheduler>) -> R) -> R {
+        Self::with_seed(0, f)
+    }
+
+    /// Run a test multiple times with sequential seeds (0, 1, 2, ...)
+    pub fn many<R>(iterations: usize, mut f: impl AsyncFnMut(Arc<TestScheduler>) -> R) -> Vec<R> {
+        (0..iterations as u64)
+            .map(|seed| {
+                let mut unwind_safe_f = AssertUnwindSafe(&mut f);
+                match panic::catch_unwind(move || Self::with_seed(seed, &mut *unwind_safe_f)) {
+                    Ok(result) => result,
+                    Err(error) => {
+                        eprintln!("Failing Seed: {seed}");
+                        panic::resume_unwind(error);
+                    }
+                }
+            })
+            .collect()
+    }
+
+    /// Run a test once with a specific seed
+    pub fn with_seed<R>(seed: u64, f: impl AsyncFnOnce(Arc<TestScheduler>) -> R) -> R {
+        let scheduler = Arc::new(TestScheduler::new(SchedulerConfig::with_seed(seed)));
+        let future = f(scheduler.clone());
+        let result = scheduler.block_on(future);
+        scheduler.run();
+        result
+    }
+
+    pub fn new(config: SchedulerConfig) -> Self {
+        Self {
+            rng: Arc::new(Mutex::new(StdRng::seed_from_u64(config.seed))),
+            state: Mutex::new(SchedulerState {
+                runnables: VecDeque::new(),
+                timers: Vec::new(),
+                randomize_order: config.randomize_order,
+                allow_parking: config.allow_parking,
+                next_session_id: SessionId(0),
+            }),
+            thread_id: thread::current().id(),
+            clock: Arc::new(TestClock::new()),
+            config,
+        }
+    }
+
+    pub fn clock(&self) -> Arc<TestClock> {
+        self.clock.clone()
+    }
+
+    pub fn rng(&self) -> Arc<Mutex<StdRng>> {
+        self.rng.clone()
+    }
+
+    /// Create a foreground executor for this scheduler
+    pub fn foreground(self: &Arc<Self>) -> ForegroundExecutor {
+        let session_id = {
+            let mut state = self.state.lock();
+            state.next_session_id.0 += 1;
+            state.next_session_id
+        };
+        ForegroundExecutor::new(session_id, self.clone())
+    }
+
+    /// Create a background executor for this scheduler
+    pub fn background(self: &Arc<Self>) -> BackgroundExecutor {
+        BackgroundExecutor::new(self.clone())
+    }
+
+    pub fn block_on<Fut: Future>(&self, future: Fut) -> Fut::Output {
+        (self as &dyn Scheduler).block_on(future)
+    }
+
+    pub fn yield_random(&self) -> Yield {
+        Yield(self.rng.lock().random_range(0..20))
+    }
+
+    pub fn run(&self) {
+        while self.step() || self.advance_clock() {
+            // Continue until no work remains
+        }
+    }
+
+    fn step(&self) -> bool {
+        let elapsed_timers = {
+            let mut state = self.state.lock();
+            let end_ix = state
+                .timers
+                .partition_point(|timer| timer.expiration <= self.clock.now());
+            state.timers.drain(..end_ix).collect::<Vec<_>>()
+        };
+
+        if !elapsed_timers.is_empty() {
+            return true;
+        }
+
+        let runnable = self.state.lock().runnables.pop_front();
+        if let Some(runnable) = runnable {
+            runnable.run();
+            return true;
+        }
+
+        false
+    }
+
+    fn advance_clock(&self) -> bool {
+        if let Some(timer) = self.state.lock().timers.first() {
+            self.clock.set_now(timer.expiration);
+            true
+        } else {
+            false
+        }
+    }
+}
+
+impl Scheduler for TestScheduler {
+    fn is_main_thread(&self) -> bool {
+        thread::current().id() == self.thread_id
+    }
+
+    fn schedule_foreground(&self, session_id: SessionId, runnable: Runnable) {
+        let mut state = self.state.lock();
+        let ix = if state.randomize_order {
+            let start_ix = state
+                .runnables
+                .iter()
+                .rposition(|task| task.session_id == Some(session_id))
+                .map_or(0, |ix| ix + 1);
+            self.rng
+                .lock()
+                .random_range(start_ix..=state.runnables.len())
+        } else {
+            state.runnables.len()
+        };
+        state.runnables.insert(
+            ix,
+            ScheduledRunnable {
+                session_id: Some(session_id),
+                runnable,
+            },
+        );
+    }
+
+    fn schedule_background(&self, runnable: Runnable) {
+        let mut state = self.state.lock();
+        let ix = if state.randomize_order {
+            self.rng.lock().random_range(0..=state.runnables.len())
+        } else {
+            state.runnables.len()
+        };
+        state.runnables.insert(
+            ix,
+            ScheduledRunnable {
+                session_id: None,
+                runnable,
+            },
+        );
+    }
+
+    fn timer(&self, duration: Duration) -> Timer {
+        let (tx, rx) = oneshot::channel();
+        let expiration = self.clock.now() + ChronoDuration::from_std(duration).unwrap();
+        let state = &mut *self.state.lock();
+        state.timers.push(ScheduledTimer {
+            expiration,
+            _notify: tx,
+        });
+        state.timers.sort_by_key(|timer| timer.expiration);
+        Timer(rx)
+    }
+
+    /// Block until the given future completes, with an optional timeout. If the
+    /// future is unable to make progress at any moment before the timeout and
+    /// no other tasks or timers remain, we panic unless parking is allowed. If
+    /// parking is allowed, we block up to the timeout or indefinitely if none
+    /// is provided. This is to allow testing a mix of deterministic and
+    /// non-deterministic async behavior, such as when interacting with I/O in
+    /// an otherwise deterministic test.
+    fn block(&self, mut future: LocalBoxFuture<()>, timeout: Option<Duration>) {
+        let (parker, unparker) = parking::pair();
+        let deadline = timeout.map(|timeout| Instant::now() + timeout);
+        let awoken = Arc::new(AtomicBool::new(false));
+        let waker = Waker::from(Arc::new(WakerFn::new({
+            let awoken = awoken.clone();
+            move || {
+                awoken.store(true, SeqCst);
+                unparker.unpark();
+            }
+        })));
+        let max_ticks = if timeout.is_some() {
+            self.rng
+                .lock()
+                .random_range(0..=self.config.max_timeout_ticks)
+        } else {
+            usize::MAX
+        };
+        let mut cx = Context::from_waker(&waker);
+
+        for _ in 0..max_ticks {
+            let Poll::Pending = future.poll_unpin(&mut cx) else {
+                break;
+            };
+
+            let mut stepped = None;
+            while self.rng.lock().random() && stepped.unwrap_or(true) {
+                *stepped.get_or_insert(false) |= self.step();
+            }
+
+            let stepped = stepped.unwrap_or(true);
+            let awoken = awoken.swap(false, SeqCst);
+            if !stepped && !awoken && !self.advance_clock() {
+                if self.state.lock().allow_parking {
+                    if !park(&parker, deadline) {
+                        break;
+                    }
+                } else if deadline.is_some() {
+                    break;
+                } else {
+                    panic!("Parking forbidden");
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct SchedulerConfig {
+    pub seed: u64,
+    pub randomize_order: bool,
+    pub allow_parking: bool,
+    pub max_timeout_ticks: usize,
+}
+
+impl SchedulerConfig {
+    pub fn with_seed(seed: u64) -> Self {
+        Self {
+            seed,
+            ..Default::default()
+        }
+    }
+}
+
+impl Default for SchedulerConfig {
+    fn default() -> Self {
+        Self {
+            seed: 0,
+            randomize_order: true,
+            allow_parking: false,
+            max_timeout_ticks: 1000,
+        }
+    }
+}
+
+struct ScheduledRunnable {
+    session_id: Option<SessionId>,
+    runnable: Runnable,
+}
+
+impl ScheduledRunnable {
+    fn run(self) {
+        self.runnable.run();
+    }
+}
+
+struct ScheduledTimer {
+    expiration: DateTime<Utc>,
+    _notify: oneshot::Sender<()>,
+}
+
+struct SchedulerState {
+    runnables: VecDeque<ScheduledRunnable>,
+    timers: Vec<ScheduledTimer>,
+    randomize_order: bool,
+    allow_parking: bool,
+    next_session_id: SessionId,
+}
+
+struct WakerFn<F> {
+    f: F,
+}
+
+impl<F: Fn()> WakerFn<F> {
+    fn new(f: F) -> Self {
+        Self { f }
+    }
+}
+
+impl<F: Fn()> Wake for WakerFn<F> {
+    fn wake(self: Arc<Self>) {
+        (self.f)();
+    }
+
+    fn wake_by_ref(self: &Arc<Self>) {
+        (self.f)();
+    }
+}
+
+pub struct Yield(usize);
+
+impl Future for Yield {
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+        if self.0 == 0 {
+            Poll::Ready(())
+        } else {
+            self.0 -= 1;
+            cx.waker().wake_by_ref();
+            Poll::Pending
+        }
+    }
+}
+
+fn park(parker: &parking::Parker, deadline: Option<Instant>) -> bool {
+    if let Some(deadline) = deadline {
+        parker.park_deadline(deadline)
+    } else {
+        parker.park();
+        true
+    }
+}
diff --git a/crates/scheduler/src/tests.rs b/crates/scheduler/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..19eb354e979083b1ec070bd5d09e5871001a8c4f
--- /dev/null
+++ b/crates/scheduler/src/tests.rs
@@ -0,0 +1,348 @@
+use super::*;
+use futures::{
+    FutureExt,
+    channel::{mpsc, oneshot},
+    executor::block_on,
+    future,
+    sink::SinkExt,
+    stream::{FuturesUnordered, StreamExt},
+};
+use std::{
+    cell::RefCell,
+    collections::{BTreeSet, HashSet},
+    pin::Pin,
+    rc::Rc,
+    sync::Arc,
+    task::{Context, Poll},
+};
+
+#[test]
+fn test_foreground_executor_spawn() {
+    let result = TestScheduler::once(async |scheduler| {
+        let task = scheduler.foreground().spawn(async move { 42 });
+        task.await
+    });
+    assert_eq!(result, 42);
+}
+
+#[test]
+fn test_background_executor_spawn() {
+    TestScheduler::once(async |scheduler| {
+        let task = scheduler.background().spawn(async move { 42 });
+        let result = task.await;
+        assert_eq!(result, 42);
+    });
+}
+
+#[test]
+fn test_foreground_ordering() {
+    let mut traces = HashSet::new();
+
+    TestScheduler::many(100, async |scheduler| {
+        #[derive(Hash, PartialEq, Eq)]
+        struct TraceEntry {
+            session: usize,
+            task: usize,
+        }
+
+        let trace = Rc::new(RefCell::new(Vec::new()));
+
+        let foreground_1 = scheduler.foreground();
+        for task in 0..10 {
+            foreground_1
+                .spawn({
+                    let trace = trace.clone();
+                    async move {
+                        trace.borrow_mut().push(TraceEntry { session: 0, task });
+                    }
+                })
+                .detach();
+        }
+
+        let foreground_2 = scheduler.foreground();
+        for task in 0..10 {
+            foreground_2
+                .spawn({
+                    let trace = trace.clone();
+                    async move {
+                        trace.borrow_mut().push(TraceEntry { session: 1, task });
+                    }
+                })
+                .detach();
+        }
+
+        scheduler.run();
+
+        assert_eq!(
+            trace
+                .borrow()
+                .iter()
+                .filter(|entry| entry.session == 0)
+                .map(|entry| entry.task)
+                .collect::<Vec<_>>(),
+            (0..10).collect::<Vec<_>>()
+        );
+        assert_eq!(
+            trace
+                .borrow()
+                .iter()
+                .filter(|entry| entry.session == 1)
+                .map(|entry| entry.task)
+                .collect::<Vec<_>>(),
+            (0..10).collect::<Vec<_>>()
+        );
+
+        traces.insert(trace.take());
+    });
+
+    assert!(traces.len() > 1, "Expected at least two traces");
+}
+
+#[test]
+fn test_timer_ordering() {
+    TestScheduler::many(1, async |scheduler| {
+        let background = scheduler.background();
+        let futures = FuturesUnordered::new();
+        futures.push(
+            async {
+                background.timer(Duration::from_millis(100)).await;
+                2
+            }
+            .boxed(),
+        );
+        futures.push(
+            async {
+                background.timer(Duration::from_millis(50)).await;
+                1
+            }
+            .boxed(),
+        );
+        futures.push(
+            async {
+                background.timer(Duration::from_millis(150)).await;
+                3
+            }
+            .boxed(),
+        );
+        assert_eq!(futures.collect::<Vec<_>>().await, vec![1, 2, 3]);
+    });
+}
+
+#[test]
+fn test_send_from_bg_to_fg() {
+    TestScheduler::once(async |scheduler| {
+        let foreground = scheduler.foreground();
+        let background = scheduler.background();
+
+        let (sender, receiver) = oneshot::channel::<i32>();
+
+        background
+            .spawn(async move {
+                sender.send(42).unwrap();
+            })
+            .detach();
+
+        let task = foreground.spawn(async move { receiver.await.unwrap() });
+        let result = task.await;
+        assert_eq!(result, 42);
+    });
+}
+
+#[test]
+fn test_randomize_order() {
+    // Test deterministic mode: different seeds should produce same execution order
+    let mut deterministic_results = HashSet::new();
+    for seed in 0..10 {
+        let config = SchedulerConfig {
+            seed,
+            randomize_order: false,
+            ..Default::default()
+        };
+        let order = block_on(capture_execution_order(config));
+        assert_eq!(order.len(), 6);
+        deterministic_results.insert(order);
+    }
+
+    // All deterministic runs should produce the same result
+    assert_eq!(
+        deterministic_results.len(),
+        1,
+        "Deterministic mode should always produce same execution order"
+    );
+
+    // Test randomized mode: different seeds can produce different execution orders
+    let mut randomized_results = HashSet::new();
+    for seed in 0..20 {
+        let config = SchedulerConfig::with_seed(seed);
+        let order = block_on(capture_execution_order(config));
+        assert_eq!(order.len(), 6);
+        randomized_results.insert(order);
+    }
+
+    // Randomized mode should produce multiple different execution orders
+    assert!(
+        randomized_results.len() > 1,
+        "Randomized mode should produce multiple different orders"
+    );
+}
+
+async fn capture_execution_order(config: SchedulerConfig) -> Vec<String> {
+    let scheduler = Arc::new(TestScheduler::new(config));
+    let foreground = scheduler.foreground();
+    let background = scheduler.background();
+
+    let (sender, receiver) = mpsc::unbounded::<String>();
+
+    // Spawn foreground tasks
+    for i in 0..3 {
+        let mut sender = sender.clone();
+        foreground
+            .spawn(async move {
+                sender.send(format!("fg-{}", i)).await.ok();
+            })
+            .detach();
+    }
+
+    // Spawn background tasks
+    for i in 0..3 {
+        let mut sender = sender.clone();
+        background
+            .spawn(async move {
+                sender.send(format!("bg-{}", i)).await.ok();
+            })
+            .detach();
+    }
+
+    drop(sender); // Close sender to signal no more messages
+    scheduler.run();
+
+    receiver.collect().await
+}
+
+#[test]
+fn test_block() {
+    let scheduler = Arc::new(TestScheduler::new(SchedulerConfig::default()));
+    let executor = BackgroundExecutor::new(scheduler);
+    let (tx, rx) = oneshot::channel();
+
+    // Spawn background task to send value
+    let _ = executor
+        .spawn(async move {
+            tx.send(42).unwrap();
+        })
+        .detach();
+
+    // Block on receiving the value
+    let result = executor.block_on(async { rx.await.unwrap() });
+    assert_eq!(result, 42);
+}
+
+#[test]
+#[should_panic(expected = "Parking forbidden")]
+fn test_parking_panics() {
+    let scheduler = Arc::new(TestScheduler::new(SchedulerConfig::default()));
+    let executor = BackgroundExecutor::new(scheduler);
+    executor.block_on(future::pending::<()>());
+}
+
+#[test]
+fn test_block_with_parking() {
+    let config = SchedulerConfig {
+        allow_parking: true,
+        ..Default::default()
+    };
+    let scheduler = Arc::new(TestScheduler::new(config));
+    let executor = BackgroundExecutor::new(scheduler);
+    let (tx, rx) = oneshot::channel();
+
+    // Spawn background task to send value
+    let _ = executor
+        .spawn(async move {
+            tx.send(42).unwrap();
+        })
+        .detach();
+
+    // Block on receiving the value (will park if needed)
+    let result = executor.block_on(async { rx.await.unwrap() });
+    assert_eq!(result, 42);
+}
+
+#[test]
+fn test_helper_methods() {
+    // Test the once method
+    let result = TestScheduler::once(async |scheduler: Arc<TestScheduler>| {
+        let background = scheduler.background();
+        background.spawn(async { 42 }).await
+    });
+    assert_eq!(result, 42);
+
+    // Test the many method
+    let results = TestScheduler::many(3, async |scheduler: Arc<TestScheduler>| {
+        let background = scheduler.background();
+        background.spawn(async { 10 }).await
+    });
+    assert_eq!(results, vec![10, 10, 10]);
+
+    // Test the with_seed method
+    let result = TestScheduler::with_seed(123, async |scheduler: Arc<TestScheduler>| {
+        let background = scheduler.background();
+
+        // Spawn a background task and wait for its result
+        let task = background.spawn(async { 99 });
+        task.await
+    });
+    assert_eq!(result, 99);
+}
+
+#[test]
+fn test_block_with_timeout() {
+    // Test case: future completes within timeout
+    TestScheduler::once(async |scheduler| {
+        let background = scheduler.background();
+        let mut future = future::ready(42);
+        let output = background.block_with_timeout(&mut future, Duration::from_millis(100));
+        assert_eq!(output, Some(42));
+    });
+
+    // Test case: future times out
+    TestScheduler::once(async |scheduler| {
+        let background = scheduler.background();
+        let mut future = future::pending::<()>();
+        let output = background.block_with_timeout(&mut future, Duration::from_millis(50));
+        assert_eq!(output, None);
+    });
+
+    // Test case: future makes progress via timer but still times out
+    let mut results = BTreeSet::new();
+    TestScheduler::many(100, async |scheduler| {
+        let background = scheduler.background();
+        let mut task = background.spawn(async move {
+            Yield { polls: 10 }.await;
+            42
+        });
+        let output = background.block_with_timeout(&mut task, Duration::from_millis(50));
+        results.insert(output);
+    });
+    assert_eq!(
+        results.into_iter().collect::<Vec<_>>(),
+        vec![None, Some(42)]
+    );
+}
+
+struct Yield {
+    polls: usize,
+}
+
+impl Future for Yield {
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        self.polls -= 1;
+        if self.polls == 0 {
+            Poll::Ready(())
+        } else {
+            cx.waker().wake_by_ref();
+            Poll::Pending
+        }
+    }
+}
diff --git a/crates/search/src/project_search.rs b/crates/search/src/project_search.rs
index 4a2dbf31fc96b43db34bd9977fafb09cc5ad60d1..80ed0958b747320481636f1d583aed1298d012c0 100644
--- a/crates/search/src/project_search.rs
+++ b/crates/search/src/project_search.rs
@@ -36,10 +36,7 @@ use std::{
     pin::pin,
     sync::Arc,
 };
-use ui::{
-    Icon, IconButton, IconButtonShape, IconName, KeyBinding, Label, LabelCommon, LabelSize,
-    Toggleable, Tooltip, h_flex, prelude::*, utils::SearchInputWidth, v_flex,
-};
+use ui::{IconButtonShape, KeyBinding, Toggleable, Tooltip, prelude::*, utils::SearchInputWidth};
 use util::{ResultExt as _, paths::PathMatcher};
 use workspace::{
     DeploySearch, ItemNavHistory, NewSearch, ToolbarItemEvent, ToolbarItemLocation,
@@ -3201,6 +3198,7 @@ pub mod tests {
                 .read(cx)
                 .entry_for_path(&(worktree_id, "a").into(), cx)
                 .expect("no entry for /a/ directory")
+                .clone()
         });
         assert!(a_dir_entry.is_dir());
         window
diff --git a/crates/search/src/search_bar.rs b/crates/search/src/search_bar.rs
index 44f6b3fdd21388f37cfbe2011e5a3e530b0be654..631b96b69f3b9aedd4ed299953edf6e63665ba99 100644
--- a/crates/search/src/search_bar.rs
+++ b/crates/search/src/search_bar.rs
@@ -41,15 +41,15 @@ pub(super) fn render_action_button(
 
 pub(crate) fn input_base_styles(border_color: Hsla, map: impl FnOnce(Div) -> Div) -> Div {
     h_flex()
-        .min_w_32()
         .map(map)
+        .min_w_32()
         .h_8()
         .pl_2()
         .pr_1()
         .py_1()
         .border_1()
         .border_color(border_color)
-        .rounded_lg()
+        .rounded_md()
 }
 
 pub(crate) fn render_text_input(
diff --git a/crates/semantic_index/Cargo.toml b/crates/semantic_index/Cargo.toml
deleted file mode 100644
index c5fe14d9cf9b79e55343b2943b49eb9d6f1a139b..0000000000000000000000000000000000000000
--- a/crates/semantic_index/Cargo.toml
+++ /dev/null
@@ -1,69 +0,0 @@
-[package]
-name = "semantic_index"
-description = "Process, chunk, and embed text as vectors for semantic search."
-version = "0.1.0"
-edition.workspace = true
-publish.workspace = true
-license = "GPL-3.0-or-later"
-
-[lints]
-workspace = true
-
-[lib]
-path = "src/semantic_index.rs"
-
-[[example]]
-name = "index"
-path = "examples/index.rs"
-crate-type = ["bin"]
-
-[dependencies]
-anyhow.workspace = true
-arrayvec.workspace = true
-blake3.workspace = true
-client.workspace = true
-clock.workspace = true
-collections.workspace = true
-feature_flags.workspace = true
-fs.workspace = true
-futures-batch.workspace = true
-futures.workspace = true
-gpui.workspace = true
-heed.workspace = true
-http_client.workspace = true
-language.workspace = true
-language_model.workspace = true
-log.workspace = true
-open_ai.workspace = true
-parking_lot.workspace = true
-project.workspace = true
-serde.workspace = true
-serde_json.workspace = true
-settings.workspace = true
-sha2.workspace = true
-smol.workspace = true
-streaming-iterator.workspace = true
-theme.workspace = true
-tree-sitter.workspace = true
-ui.workspace = true
-unindent.workspace = true
-util.workspace = true
-workspace.workspace = true
-worktree.workspace = true
-workspace-hack.workspace = true
-
-[dev-dependencies]
-client = { workspace = true, features = ["test-support"] }
-fs = { workspace = true, features = ["test-support"] }
-futures.workspace = true
-gpui = { workspace = true, features = ["test-support"] }
-http_client = { workspace = true, features = ["test-support"] }
-language = { workspace = true, features = ["test-support"] }
-languages.workspace = true
-project = { workspace = true, features = ["test-support"] }
-tempfile.workspace = true
-reqwest_client.workspace = true
-util = { workspace = true, features = ["test-support"] }
-workspace = { workspace = true, features = ["test-support"] }
-worktree = { workspace = true, features = ["test-support"] }
-zlog.workspace = true
diff --git a/crates/semantic_index/examples/index.rs b/crates/semantic_index/examples/index.rs
deleted file mode 100644
index 86f1e53a606c5a38846e937347f20b6166a7b728..0000000000000000000000000000000000000000
--- a/crates/semantic_index/examples/index.rs
+++ /dev/null
@@ -1,140 +0,0 @@
-use client::Client;
-use futures::channel::oneshot;
-use gpui::Application;
-use http_client::HttpClientWithUrl;
-use language::language_settings::AllLanguageSettings;
-use project::Project;
-use semantic_index::{OpenAiEmbeddingModel, OpenAiEmbeddingProvider, SemanticDb};
-use settings::SettingsStore;
-use std::{
-    path::{Path, PathBuf},
-    sync::Arc,
-};
-
-fn main() {
-    zlog::init();
-
-    use clock::FakeSystemClock;
-
-    Application::new().run(|cx| {
-        let store = SettingsStore::test(cx);
-        cx.set_global(store);
-        language::init(cx);
-        Project::init_settings(cx);
-        SettingsStore::update(cx, |store, cx| {
-            store.update_user_settings::<AllLanguageSettings>(cx, |_| {});
-        });
-
-        let clock = Arc::new(FakeSystemClock::new());
-
-        let http = Arc::new(HttpClientWithUrl::new(
-            Arc::new(
-                reqwest_client::ReqwestClient::user_agent("Zed semantic index example").unwrap(),
-            ),
-            "http://localhost:11434",
-            None,
-        ));
-        let client = client::Client::new(clock, http.clone(), cx);
-        Client::set_global(client, cx);
-
-        let args: Vec<String> = std::env::args().collect();
-        if args.len() < 2 {
-            eprintln!("Usage: cargo run --example index -p semantic_index -- <project_path>");
-            cx.quit();
-            return;
-        }
-
-        // let embedding_provider = semantic_index::FakeEmbeddingProvider;
-
-        let api_key = std::env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY not set");
-
-        let embedding_provider = Arc::new(OpenAiEmbeddingProvider::new(
-            http,
-            OpenAiEmbeddingModel::TextEmbedding3Small,
-            open_ai::OPEN_AI_API_URL.to_string(),
-            api_key,
-        ));
-
-        cx.spawn(async move |cx| {
-            let semantic_index = SemanticDb::new(
-                PathBuf::from("/tmp/semantic-index-db.mdb"),
-                embedding_provider,
-                cx,
-            );
-
-            let mut semantic_index = semantic_index.await.unwrap();
-
-            let project_path = Path::new(&args[1]);
-
-            let project = Project::example([project_path], cx).await;
-
-            cx.update(|cx| {
-                let language_registry = project.read(cx).languages().clone();
-                let node_runtime = project.read(cx).node_runtime().unwrap().clone();
-                languages::init(language_registry, node_runtime, cx);
-            })
-            .unwrap();
-
-            let project_index = cx
-                .update(|cx| semantic_index.project_index(project.clone(), cx))
-                .unwrap()
-                .unwrap();
-
-            let (tx, rx) = oneshot::channel();
-            let mut tx = Some(tx);
-            let subscription = cx.update(|cx| {
-                cx.subscribe(&project_index, move |_, event, _| {
-                    if let Some(tx) = tx.take() {
-                        _ = tx.send(*event);
-                    }
-                })
-            });
-
-            let index_start = std::time::Instant::now();
-            rx.await.expect("no event emitted");
-            drop(subscription);
-            println!("Index time: {:?}", index_start.elapsed());
-
-            let results = cx
-                .update(|cx| {
-                    let project_index = project_index.read(cx);
-                    let query = "converting an anchor to a point";
-                    project_index.search(vec![query.into()], 4, cx)
-                })
-                .unwrap()
-                .await
-                .unwrap();
-
-            for search_result in results {
-                let path = search_result.path.clone();
-
-                let content = cx
-                    .update(|cx| {
-                        let worktree = search_result.worktree.read(cx);
-                        let entry_abs_path = worktree.abs_path().join(search_result.path.clone());
-                        let fs = project.read(cx).fs().clone();
-                        cx.spawn(async move |_| fs.load(&entry_abs_path).await.unwrap())
-                    })
-                    .unwrap()
-                    .await;
-
-                let range = search_result.range.clone();
-                let content = content[search_result.range].to_owned();
-
-                println!(
-                    "✄✄✄✄✄✄✄✄✄✄✄✄✄✄ {:?} @ {} ✄✄✄✄✄✄✄✄✄✄✄✄✄✄",
-                    path, search_result.score
-                );
-                println!("{:?}:{:?}:{:?}", path, range.start, range.end);
-                println!("{}", content);
-            }
-
-            cx.background_executor()
-                .timer(std::time::Duration::from_secs(100000))
-                .await;
-
-            cx.update(|cx| cx.quit()).unwrap();
-        })
-        .detach();
-    });
-}
diff --git a/crates/semantic_index/fixture/main.rs b/crates/semantic_index/fixture/main.rs
deleted file mode 100644
index f8796c8f4528a1113c37b72ca871bc2195f45619..0000000000000000000000000000000000000000
--- a/crates/semantic_index/fixture/main.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-fn main() {
-    println!("Hello Indexer!");
-}
diff --git a/crates/semantic_index/fixture/needle.md b/crates/semantic_index/fixture/needle.md
deleted file mode 100644
index 80487c9983a8f5ac151ac463126ea96aff59d6ca..0000000000000000000000000000000000000000
--- a/crates/semantic_index/fixture/needle.md
+++ /dev/null
@@ -1,43 +0,0 @@
-# Searching for a needle in a haystack
-
-When you have a large amount of text, it can be useful to search for a specific word or phrase. This is often referred to as "finding a needle in a haystack." In this markdown document, we're "hiding" a key phrase for our text search to find. Can you find it?
-
-## Instructions
-
-1. Use the search functionality in your text editor or markdown viewer to find the hidden phrase in this document.
-
-2. Once you've found the **phrase**, write it down and proceed to the next step.
-
-Honestly, I just want to fill up plenty of characters so that we chunk this markdown into several chunks.
-
-## Tips
-
-- Relax
-- Take a deep breath
-- Focus on the task at hand
-- Don't get distracted by other text
-- Use the search functionality to your advantage
-
-## Example code
-
-```python
-def search_for_needle(haystack, needle):
-    if needle in haystack:
-        return True
-    else:
-        return False
-```
-
-```javascript
-function searchForNeedle(haystack, needle) {
-  return haystack.includes(needle);
-}
-```
-
-## Background
-
-When creating an index for a book or searching for a specific term in a large document, the ability to quickly find a specific word or phrase is essential. This is where search functionality comes in handy. However, one should _remember_ that the search is only as good as the index that was built. As they say, garbage in, garbage out!
-
-## Conclusion
-
-Searching for a needle in a haystack can be a challenging task, but with the right tools and techniques, it becomes much easier. Whether you're looking for a specific word in a document or trying to find a key piece of information in a large dataset, the ability to search efficiently is a valuable skill to have.
diff --git a/crates/semantic_index/src/chunking.rs b/crates/semantic_index/src/chunking.rs
deleted file mode 100644
index c1dfb6ccb5e71713f22183637d2ae14b16ac89f0..0000000000000000000000000000000000000000
--- a/crates/semantic_index/src/chunking.rs
+++ /dev/null
@@ -1,415 +0,0 @@
-use language::{Language, with_parser, with_query_cursor};
-use serde::{Deserialize, Serialize};
-use sha2::{Digest, Sha256};
-use std::{
-    cmp::{self, Reverse},
-    ops::Range,
-    path::Path,
-    sync::Arc,
-};
-use streaming_iterator::StreamingIterator;
-use tree_sitter::QueryCapture;
-use util::ResultExt as _;
-
-#[derive(Copy, Clone)]
-struct ChunkSizeRange {
-    min: usize,
-    max: usize,
-}
-
-const CHUNK_SIZE_RANGE: ChunkSizeRange = ChunkSizeRange {
-    min: 1024,
-    max: 8192,
-};
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Chunk {
-    pub range: Range<usize>,
-    pub digest: [u8; 32],
-}
-
-pub fn chunk_text(text: &str, language: Option<&Arc<Language>>, path: &Path) -> Vec<Chunk> {
-    chunk_text_with_size_range(text, language, path, CHUNK_SIZE_RANGE)
-}
-
-fn chunk_text_with_size_range(
-    text: &str,
-    language: Option<&Arc<Language>>,
-    path: &Path,
-    size_config: ChunkSizeRange,
-) -> Vec<Chunk> {
-    let ranges = syntactic_ranges(text, language, path).unwrap_or_default();
-    chunk_text_with_syntactic_ranges(text, &ranges, size_config)
-}
-
-fn syntactic_ranges(
-    text: &str,
-    language: Option<&Arc<Language>>,
-    path: &Path,
-) -> Option<Vec<Range<usize>>> {
-    let language = language?;
-    let grammar = language.grammar()?;
-    let outline = grammar.outline_config.as_ref()?;
-    let tree = with_parser(|parser| {
-        parser.set_language(&grammar.ts_language).log_err()?;
-        parser.parse(text, None)
-    });
-
-    let Some(tree) = tree else {
-        log::error!("failed to parse file {path:?} for chunking");
-        return None;
-    };
-
-    struct RowInfo {
-        offset: usize,
-        is_comment: bool,
-    }
-
-    let scope = language.default_scope();
-    let line_comment_prefixes = scope.line_comment_prefixes();
-    let row_infos = text
-        .split('\n')
-        .map({
-            let mut offset = 0;
-            move |line| {
-                let line = line.trim_start();
-                let is_comment = line_comment_prefixes
-                    .iter()
-                    .any(|prefix| line.starts_with(prefix.as_ref()));
-                let result = RowInfo { offset, is_comment };
-                offset += line.len() + 1;
-                result
-            }
-        })
-        .collect::<Vec<_>>();
-
-    // Retrieve a list of ranges of outline items (types, functions, etc) in the document.
-    // Omit single-line outline items (e.g. struct fields, constant declarations), because
-    // we'll already be attempting to split on lines.
-    let mut ranges = with_query_cursor(|cursor| {
-        cursor
-            .matches(&outline.query, tree.root_node(), text.as_bytes())
-            .filter_map_deref(|mat| {
-                mat.captures
-                    .iter()
-                    .find_map(|QueryCapture { node, index }| {
-                        if *index == outline.item_capture_ix {
-                            let mut start_offset = node.start_byte();
-                            let mut start_row = node.start_position().row;
-                            let end_offset = node.end_byte();
-                            let end_row = node.end_position().row;
-
-                            // Expand the range to include any preceding comments.
-                            while start_row > 0 && row_infos[start_row - 1].is_comment {
-                                start_offset = row_infos[start_row - 1].offset;
-                                start_row -= 1;
-                            }
-
-                            if end_row > start_row {
-                                return Some(start_offset..end_offset);
-                            }
-                        }
-                        None
-                    })
-            })
-            .collect::<Vec<_>>()
-    });
-
-    ranges.sort_unstable_by_key(|range| (range.start, Reverse(range.end)));
-    Some(ranges)
-}
-
-fn chunk_text_with_syntactic_ranges(
-    text: &str,
-    mut syntactic_ranges: &[Range<usize>],
-    size_config: ChunkSizeRange,
-) -> Vec<Chunk> {
-    let mut chunks = Vec::new();
-    let mut range = 0..0;
-    let mut range_end_nesting_depth = 0;
-
-    // Try to split the text at line boundaries.
-    let mut line_ixs = text
-        .match_indices('\n')
-        .map(|(ix, _)| ix + 1)
-        .chain(if text.ends_with('\n') {
-            None
-        } else {
-            Some(text.len())
-        })
-        .peekable();
-
-    while let Some(&line_ix) = line_ixs.peek() {
-        // If the current position is beyond the maximum chunk size, then
-        // start a new chunk.
-        if line_ix - range.start > size_config.max {
-            if range.is_empty() {
-                range.end = cmp::min(range.start + size_config.max, line_ix);
-                while !text.is_char_boundary(range.end) {
-                    range.end -= 1;
-                }
-            }
-
-            chunks.push(Chunk {
-                range: range.clone(),
-                digest: Sha256::digest(&text[range.clone()]).into(),
-            });
-            range_end_nesting_depth = 0;
-            range.start = range.end;
-            continue;
-        }
-
-        // Discard any syntactic ranges that end before the current position.
-        while let Some(first_item) = syntactic_ranges.first() {
-            if first_item.end < line_ix {
-                syntactic_ranges = &syntactic_ranges[1..];
-                continue;
-            } else {
-                break;
-            }
-        }
-
-        // Count how many syntactic ranges contain the current position.
-        let mut nesting_depth = 0;
-        for range in syntactic_ranges {
-            if range.start > line_ix {
-                break;
-            }
-            if range.start < line_ix && range.end > line_ix {
-                nesting_depth += 1;
-            }
-        }
-
-        // Extend the current range to this position, unless an earlier candidate
-        // end position was less nested syntactically.
-        if range.len() < size_config.min || nesting_depth <= range_end_nesting_depth {
-            range.end = line_ix;
-            range_end_nesting_depth = nesting_depth;
-        }
-
-        line_ixs.next();
-    }
-
-    if !range.is_empty() {
-        chunks.push(Chunk {
-            range: range.clone(),
-            digest: Sha256::digest(&text[range]).into(),
-        });
-    }
-
-    chunks
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use language::{Language, LanguageConfig, LanguageMatcher, tree_sitter_rust};
-    use unindent::Unindent as _;
-
-    #[test]
-    fn test_chunk_text_with_syntax() {
-        let language = rust_language();
-
-        let text = "
-            struct Person {
-                first_name: String,
-                last_name: String,
-                age: u32,
-            }
-
-            impl Person {
-                fn new(first_name: String, last_name: String, age: u32) -> Self {
-                    Self { first_name, last_name, age }
-                }
-
-                /// Returns the first name
-                /// something something something
-                fn first_name(&self) -> &str {
-                    &self.first_name
-                }
-
-                fn last_name(&self) -> &str {
-                    &self.last_name
-                }
-
-                fn age(&self) -> u32 {
-                    self.age
-                }
-            }
-        "
-        .unindent();
-
-        let chunks = chunk_text_with_size_range(
-            &text,
-            Some(&language),
-            Path::new("lib.rs"),
-            ChunkSizeRange {
-                min: text.find('}').unwrap(),
-                max: text.find("Self {").unwrap(),
-            },
-        );
-
-        // The entire impl cannot fit in a chunk, so it is split.
-        // Within the impl, two methods can fit in a chunk.
-        assert_chunks(
-            &text,
-            &chunks,
-            &[
-                "struct Person {", // ...
-                "impl Person {",
-                "    /// Returns the first name",
-                "    fn last_name",
-            ],
-        );
-
-        let text = "
-            struct T {}
-            struct U {}
-            struct V {}
-            struct W {
-                a: T,
-                b: U,
-            }
-        "
-        .unindent();
-
-        let chunks = chunk_text_with_size_range(
-            &text,
-            Some(&language),
-            Path::new("lib.rs"),
-            ChunkSizeRange {
-                min: text.find('{').unwrap(),
-                max: text.find('V').unwrap(),
-            },
-        );
-
-        // Two single-line structs can fit in a chunk.
-        // The last struct cannot fit in a chunk together
-        // with the previous single-line struct.
-        assert_chunks(
-            &text,
-            &chunks,
-            &[
-                "struct T", // ...
-                "struct V", // ...
-                "struct W", // ...
-                "}",
-            ],
-        );
-    }
-
-    #[test]
-    fn test_chunk_with_long_lines() {
-        let language = rust_language();
-
-        let text = "
-            struct S { a: u32 }
-            struct T { a: u64 }
-            struct U { a: u64, b: u64, c: u64, d: u64, e: u64, f: u64, g: u64, h: u64, i: u64, j: u64 }
-            struct W { a: u64, b: u64, c: u64, d: u64, e: u64, f: u64, g: u64, h: u64, i: u64, j: u64 }
-        "
-        .unindent();
-
-        let chunks = chunk_text_with_size_range(
-            &text,
-            Some(&language),
-            Path::new("lib.rs"),
-            ChunkSizeRange { min: 32, max: 64 },
-        );
-
-        // The line is too long to fit in one chunk
-        assert_chunks(
-            &text,
-            &chunks,
-            &[
-                "struct S {", // ...
-                "struct U",
-                "4, h: u64, i: u64", // ...
-                "struct W",
-                "4, h: u64, i: u64", // ...
-            ],
-        );
-    }
-
-    #[track_caller]
-    fn assert_chunks(text: &str, chunks: &[Chunk], expected_chunk_text_prefixes: &[&str]) {
-        check_chunk_invariants(text, chunks);
-
-        assert_eq!(
-            chunks.len(),
-            expected_chunk_text_prefixes.len(),
-            "unexpected number of chunks: {chunks:?}",
-        );
-
-        let mut prev_chunk_end = 0;
-        for (ix, chunk) in chunks.iter().enumerate() {
-            let expected_prefix = expected_chunk_text_prefixes[ix];
-            let chunk_text = &text[chunk.range.clone()];
-            if !chunk_text.starts_with(expected_prefix) {
-                let chunk_prefix_offset = text[prev_chunk_end..].find(expected_prefix);
-                if let Some(chunk_prefix_offset) = chunk_prefix_offset {
-                    panic!(
-                        "chunk {ix} starts at unexpected offset {}. expected {}",
-                        chunk.range.start,
-                        chunk_prefix_offset + prev_chunk_end
-                    );
-                } else {
-                    panic!("invalid expected chunk prefix {ix}: {expected_prefix:?}");
-                }
-            }
-            prev_chunk_end = chunk.range.end;
-        }
-    }
-
-    #[track_caller]
-    fn check_chunk_invariants(text: &str, chunks: &[Chunk]) {
-        for (ix, chunk) in chunks.iter().enumerate() {
-            if ix > 0 && chunk.range.start != chunks[ix - 1].range.end {
-                panic!("chunk ranges are not contiguous: {:?}", chunks);
-            }
-        }
-
-        if text.is_empty() {
-            assert!(chunks.is_empty())
-        } else if chunks.first().unwrap().range.start != 0
-            || chunks.last().unwrap().range.end != text.len()
-        {
-            panic!("chunks don't cover entire text {:?}", chunks);
-        }
-    }
-
-    #[test]
-    fn test_chunk_text() {
-        let text = "a\n".repeat(1000);
-        let chunks = chunk_text(&text, None, Path::new("lib.rs"));
-        assert_eq!(
-            chunks.len(),
-            ((2000_f64) / (CHUNK_SIZE_RANGE.max as f64)).ceil() as usize
-        );
-    }
-
-    fn rust_language() -> Arc<Language> {
-        Arc::new(
-            Language::new(
-                LanguageConfig {
-                    name: "Rust".into(),
-                    matcher: LanguageMatcher {
-                        path_suffixes: vec!["rs".to_string()],
-                        ..Default::default()
-                    },
-                    ..Default::default()
-                },
-                Some(tree_sitter_rust::LANGUAGE.into()),
-            )
-            .with_outline_query(
-                "
-            (function_item name: (_) @name) @item
-            (impl_item type: (_) @name) @item
-            (struct_item name: (_) @name) @item
-            (field_declaration name: (_) @name) @item
-        ",
-            )
-            .unwrap(),
-        )
-    }
-}
diff --git a/crates/semantic_index/src/embedding.rs b/crates/semantic_index/src/embedding.rs
deleted file mode 100644
index 8ca47a40230cd15cf550693a82ccffe231f5d686..0000000000000000000000000000000000000000
--- a/crates/semantic_index/src/embedding.rs
+++ /dev/null
@@ -1,134 +0,0 @@
-mod lmstudio;
-mod ollama;
-mod open_ai;
-
-pub use lmstudio::*;
-pub use ollama::*;
-pub use open_ai::*;
-use sha2::{Digest, Sha256};
-
-use anyhow::Result;
-use futures::{FutureExt, future::BoxFuture};
-use serde::{Deserialize, Serialize};
-use std::{fmt, future};
-
-/// Trait for embedding providers. Texts in, vectors out.
-pub trait EmbeddingProvider: Sync + Send {
-    fn embed<'a>(&'a self, texts: &'a [TextToEmbed<'a>]) -> BoxFuture<'a, Result<Vec<Embedding>>>;
-    fn batch_size(&self) -> usize;
-}
-
-#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
-pub struct Embedding(Vec<f32>);
-
-impl Embedding {
-    pub fn new(mut embedding: Vec<f32>) -> Self {
-        let len = embedding.len();
-        let mut norm = 0f32;
-
-        for i in 0..len {
-            norm += embedding[i] * embedding[i];
-        }
-
-        norm = norm.sqrt();
-        for dimension in &mut embedding {
-            *dimension /= norm;
-        }
-
-        Self(embedding)
-    }
-
-    fn len(&self) -> usize {
-        self.0.len()
-    }
-
-    pub fn similarity(&self, others: &[Embedding]) -> (f32, usize) {
-        debug_assert!(others.iter().all(|other| self.0.len() == other.0.len()));
-        others
-            .iter()
-            .enumerate()
-            .map(|(index, other)| {
-                let dot_product: f32 = self
-                    .0
-                    .iter()
-                    .copied()
-                    .zip(other.0.iter().copied())
-                    .map(|(a, b)| a * b)
-                    .sum();
-                (dot_product, index)
-            })
-            .max_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal))
-            .unwrap_or((0.0, 0))
-    }
-}
-
-impl fmt::Display for Embedding {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let digits_to_display = 3;
-
-        // Start the Embedding display format
-        write!(f, "Embedding(sized: {}; values: [", self.len())?;
-
-        for (index, value) in self.0.iter().enumerate().take(digits_to_display) {
-            // Lead with comma if not the first element
-            if index != 0 {
-                write!(f, ", ")?;
-            }
-            write!(f, "{:.3}", value)?;
-        }
-        if self.len() > digits_to_display {
-            write!(f, "...")?;
-        }
-        write!(f, "])")
-    }
-}
-
-#[derive(Debug)]
-pub struct TextToEmbed<'a> {
-    pub text: &'a str,
-    pub digest: [u8; 32],
-}
-
-impl<'a> TextToEmbed<'a> {
-    pub fn new(text: &'a str) -> Self {
-        let digest = Sha256::digest(text.as_bytes());
-        Self {
-            text,
-            digest: digest.into(),
-        }
-    }
-}
-
-pub struct FakeEmbeddingProvider;
-
-impl EmbeddingProvider for FakeEmbeddingProvider {
-    fn embed<'a>(&'a self, texts: &'a [TextToEmbed<'a>]) -> BoxFuture<'a, Result<Vec<Embedding>>> {
-        let embeddings = texts
-            .iter()
-            .map(|_text| {
-                let mut embedding = vec![0f32; 1536];
-                for i in 0..embedding.len() {
-                    embedding[i] = i as f32;
-                }
-                Embedding::new(embedding)
-            })
-            .collect();
-        future::ready(Ok(embeddings)).boxed()
-    }
-
-    fn batch_size(&self) -> usize {
-        16
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[gpui::test]
-    fn test_normalize_embedding() {
-        let normalized = Embedding::new(vec![1.0, 1.0, 1.0]);
-        let value: f32 = 1.0 / 3.0_f32.sqrt();
-        assert_eq!(normalized, Embedding(vec![value; 3]));
-    }
-}
diff --git a/crates/semantic_index/src/embedding/lmstudio.rs b/crates/semantic_index/src/embedding/lmstudio.rs
deleted file mode 100644
index 73e52aa0bfde11307a81dcbee828b86349b6efc5..0000000000000000000000000000000000000000
--- a/crates/semantic_index/src/embedding/lmstudio.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-use anyhow::{Context as _, Result};
-use futures::{AsyncReadExt as _, FutureExt, future::BoxFuture};
-use http_client::HttpClient;
-use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-
-use crate::{Embedding, EmbeddingProvider, TextToEmbed};
-
-pub enum LmStudioEmbeddingModel {
-    NomicEmbedText,
-}
-
-pub struct LmStudioEmbeddingProvider {
-    client: Arc<dyn HttpClient>,
-    model: LmStudioEmbeddingModel,
-}
-
-#[derive(Serialize)]
-struct LmStudioEmbeddingRequest {
-    model: String,
-    prompt: String,
-}
-
-#[derive(Deserialize)]
-struct LmStudioEmbeddingResponse {
-    embedding: Vec<f32>,
-}
-
-impl LmStudioEmbeddingProvider {
-    pub fn new(client: Arc<dyn HttpClient>, model: LmStudioEmbeddingModel) -> Self {
-        Self { client, model }
-    }
-}
-
-impl EmbeddingProvider for LmStudioEmbeddingProvider {
-    fn embed<'a>(&'a self, texts: &'a [TextToEmbed<'a>]) -> BoxFuture<'a, Result<Vec<Embedding>>> {
-        let model = match self.model {
-            LmStudioEmbeddingModel::NomicEmbedText => "nomic-embed-text",
-        };
-
-        futures::future::try_join_all(texts.iter().map(|to_embed| {
-            let request = LmStudioEmbeddingRequest {
-                model: model.to_string(),
-                prompt: to_embed.text.to_string(),
-            };
-
-            let request = serde_json::to_string(&request).unwrap();
-
-            async {
-                let response = self
-                    .client
-                    .post_json("http://localhost:1234/api/v0/embeddings", request.into())
-                    .await?;
-
-                let mut body = String::new();
-                response.into_body().read_to_string(&mut body).await?;
-
-                let response: LmStudioEmbeddingResponse =
-                    serde_json::from_str(&body).context("Unable to parse response")?;
-
-                Ok(Embedding::new(response.embedding))
-            }
-        }))
-        .boxed()
-    }
-
-    fn batch_size(&self) -> usize {
-        256
-    }
-}
diff --git a/crates/semantic_index/src/embedding/ollama.rs b/crates/semantic_index/src/embedding/ollama.rs
deleted file mode 100644
index 5737609e24d0cb1adca3a155c09c6045e591c152..0000000000000000000000000000000000000000
--- a/crates/semantic_index/src/embedding/ollama.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-use anyhow::{Context as _, Result};
-use futures::{AsyncReadExt as _, FutureExt, future::BoxFuture};
-use http_client::HttpClient;
-use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-
-use crate::{Embedding, EmbeddingProvider, TextToEmbed};
-
-pub enum OllamaEmbeddingModel {
-    NomicEmbedText,
-    MxbaiEmbedLarge,
-}
-
-pub struct OllamaEmbeddingProvider {
-    client: Arc<dyn HttpClient>,
-    model: OllamaEmbeddingModel,
-}
-
-#[derive(Serialize)]
-struct OllamaEmbeddingRequest {
-    model: String,
-    prompt: String,
-}
-
-#[derive(Deserialize)]
-struct OllamaEmbeddingResponse {
-    embedding: Vec<f32>,
-}
-
-impl OllamaEmbeddingProvider {
-    pub fn new(client: Arc<dyn HttpClient>, model: OllamaEmbeddingModel) -> Self {
-        Self { client, model }
-    }
-}
-
-impl EmbeddingProvider for OllamaEmbeddingProvider {
-    fn embed<'a>(&'a self, texts: &'a [TextToEmbed<'a>]) -> BoxFuture<'a, Result<Vec<Embedding>>> {
-        //
-        let model = match self.model {
-            OllamaEmbeddingModel::NomicEmbedText => "nomic-embed-text",
-            OllamaEmbeddingModel::MxbaiEmbedLarge => "mxbai-embed-large",
-        };
-
-        futures::future::try_join_all(texts.iter().map(|to_embed| {
-            let request = OllamaEmbeddingRequest {
-                model: model.to_string(),
-                prompt: to_embed.text.to_string(),
-            };
-
-            let request = serde_json::to_string(&request).unwrap();
-
-            async {
-                let response = self
-                    .client
-                    .post_json("http://localhost:11434/api/embeddings", request.into())
-                    .await?;
-
-                let mut body = String::new();
-                response.into_body().read_to_string(&mut body).await?;
-
-                let response: OllamaEmbeddingResponse =
-                    serde_json::from_str(&body).context("Unable to pull response")?;
-
-                Ok(Embedding::new(response.embedding))
-            }
-        }))
-        .boxed()
-    }
-
-    fn batch_size(&self) -> usize {
-        // TODO: Figure out decent value
-        10
-    }
-}
diff --git a/crates/semantic_index/src/embedding/open_ai.rs b/crates/semantic_index/src/embedding/open_ai.rs
deleted file mode 100644
index da2b3bd2e4d873a84c380006575d304d356e878a..0000000000000000000000000000000000000000
--- a/crates/semantic_index/src/embedding/open_ai.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-use crate::{Embedding, EmbeddingProvider, TextToEmbed};
-use anyhow::Result;
-use futures::{FutureExt, future::BoxFuture};
-use http_client::HttpClient;
-pub use open_ai::OpenAiEmbeddingModel;
-use std::sync::Arc;
-
-pub struct OpenAiEmbeddingProvider {
-    client: Arc<dyn HttpClient>,
-    model: OpenAiEmbeddingModel,
-    api_url: String,
-    api_key: String,
-}
-
-impl OpenAiEmbeddingProvider {
-    pub fn new(
-        client: Arc<dyn HttpClient>,
-        model: OpenAiEmbeddingModel,
-        api_url: String,
-        api_key: String,
-    ) -> Self {
-        Self {
-            client,
-            model,
-            api_url,
-            api_key,
-        }
-    }
-}
-
-impl EmbeddingProvider for OpenAiEmbeddingProvider {
-    fn embed<'a>(&'a self, texts: &'a [TextToEmbed<'a>]) -> BoxFuture<'a, Result<Vec<Embedding>>> {
-        let embed = open_ai::embed(
-            self.client.as_ref(),
-            &self.api_url,
-            &self.api_key,
-            self.model,
-            texts.iter().map(|to_embed| to_embed.text),
-        );
-        async move {
-            let response = embed.await?;
-            Ok(response
-                .data
-                .into_iter()
-                .map(|data| Embedding::new(data.embedding))
-                .collect())
-        }
-        .boxed()
-    }
-
-    fn batch_size(&self) -> usize {
-        // From https://platform.openai.com/docs/api-reference/embeddings/create
-        2048
-    }
-}
diff --git a/crates/semantic_index/src/embedding_index.rs b/crates/semantic_index/src/embedding_index.rs
deleted file mode 100644
index c54cd9d3c36216a00d5aca898ebe1bb0e3499f2e..0000000000000000000000000000000000000000
--- a/crates/semantic_index/src/embedding_index.rs
+++ /dev/null
@@ -1,470 +0,0 @@
-use crate::{
-    chunking::{self, Chunk},
-    embedding::{Embedding, EmbeddingProvider, TextToEmbed},
-    indexing::{IndexingEntryHandle, IndexingEntrySet},
-};
-use anyhow::{Context as _, Result};
-use collections::Bound;
-use feature_flags::FeatureFlagAppExt;
-use fs::Fs;
-use fs::MTime;
-use futures::{FutureExt as _, stream::StreamExt};
-use futures_batch::ChunksTimeoutStreamExt;
-use gpui::{App, AppContext as _, Entity, Task};
-use heed::types::{SerdeBincode, Str};
-use language::LanguageRegistry;
-use log;
-use project::{Entry, UpdatedEntriesSet, Worktree};
-use serde::{Deserialize, Serialize};
-use smol::channel;
-use std::{cmp::Ordering, future::Future, iter, path::Path, pin::pin, sync::Arc, time::Duration};
-use util::ResultExt;
-use worktree::Snapshot;
-
-pub struct EmbeddingIndex {
-    worktree: Entity<Worktree>,
-    db_connection: heed::Env,
-    db: heed::Database<Str, SerdeBincode<EmbeddedFile>>,
-    fs: Arc<dyn Fs>,
-    language_registry: Arc<LanguageRegistry>,
-    embedding_provider: Arc<dyn EmbeddingProvider>,
-    entry_ids_being_indexed: Arc<IndexingEntrySet>,
-}
-
-impl EmbeddingIndex {
-    pub fn new(
-        worktree: Entity<Worktree>,
-        fs: Arc<dyn Fs>,
-        db_connection: heed::Env,
-        embedding_db: heed::Database<Str, SerdeBincode<EmbeddedFile>>,
-        language_registry: Arc<LanguageRegistry>,
-        embedding_provider: Arc<dyn EmbeddingProvider>,
-        entry_ids_being_indexed: Arc<IndexingEntrySet>,
-    ) -> Self {
-        Self {
-            worktree,
-            fs,
-            db_connection,
-            db: embedding_db,
-            language_registry,
-            embedding_provider,
-            entry_ids_being_indexed,
-        }
-    }
-
-    pub fn db(&self) -> &heed::Database<Str, SerdeBincode<EmbeddedFile>> {
-        &self.db
-    }
-
-    pub fn index_entries_changed_on_disk(
-        &self,
-        cx: &App,
-    ) -> impl Future<Output = Result<()>> + use<> {
-        if !cx.is_staff() {
-            return async move { Ok(()) }.boxed();
-        }
-
-        let worktree = self.worktree.read(cx).snapshot();
-        let worktree_abs_path = worktree.abs_path().clone();
-        let scan = self.scan_entries(worktree, cx);
-        let chunk = self.chunk_files(worktree_abs_path, scan.updated_entries, cx);
-        let embed = Self::embed_files(self.embedding_provider.clone(), chunk.files, cx);
-        let persist = self.persist_embeddings(scan.deleted_entry_ranges, embed.files, cx);
-        async move {
-            futures::try_join!(scan.task, chunk.task, embed.task, persist)?;
-            Ok(())
-        }
-        .boxed()
-    }
-
-    pub fn index_updated_entries(
-        &self,
-        updated_entries: UpdatedEntriesSet,
-        cx: &App,
-    ) -> impl Future<Output = Result<()>> + use<> {
-        if !cx.is_staff() {
-            return async move { Ok(()) }.boxed();
-        }
-
-        let worktree = self.worktree.read(cx).snapshot();
-        let worktree_abs_path = worktree.abs_path().clone();
-        let scan = self.scan_updated_entries(worktree, updated_entries, cx);
-        let chunk = self.chunk_files(worktree_abs_path, scan.updated_entries, cx);
-        let embed = Self::embed_files(self.embedding_provider.clone(), chunk.files, cx);
-        let persist = self.persist_embeddings(scan.deleted_entry_ranges, embed.files, cx);
-        async move {
-            futures::try_join!(scan.task, chunk.task, embed.task, persist)?;
-            Ok(())
-        }
-        .boxed()
-    }
-
-    fn scan_entries(&self, worktree: Snapshot, cx: &App) -> ScanEntries {
-        let (updated_entries_tx, updated_entries_rx) = channel::bounded(512);
-        let (deleted_entry_ranges_tx, deleted_entry_ranges_rx) = channel::bounded(128);
-        let db_connection = self.db_connection.clone();
-        let db = self.db;
-        let entries_being_indexed = self.entry_ids_being_indexed.clone();
-        let task = cx.background_spawn(async move {
-            let txn = db_connection
-                .read_txn()
-                .context("failed to create read transaction")?;
-            let mut db_entries = db
-                .iter(&txn)
-                .context("failed to create iterator")?
-                .move_between_keys()
-                .peekable();
-
-            let mut deletion_range: Option<(Bound<&str>, Bound<&str>)> = None;
-            for entry in worktree.files(false, 0) {
-                log::trace!("scanning for embedding index: {:?}", &entry.path);
-
-                let entry_db_key = db_key_for_path(&entry.path);
-
-                let mut saved_mtime = None;
-                while let Some(db_entry) = db_entries.peek() {
-                    match db_entry {
-                        Ok((db_path, db_embedded_file)) => match (*db_path).cmp(&entry_db_key) {
-                            Ordering::Less => {
-                                if let Some(deletion_range) = deletion_range.as_mut() {
-                                    deletion_range.1 = Bound::Included(db_path);
-                                } else {
-                                    deletion_range =
-                                        Some((Bound::Included(db_path), Bound::Included(db_path)));
-                                }
-
-                                db_entries.next();
-                            }
-                            Ordering::Equal => {
-                                if let Some(deletion_range) = deletion_range.take() {
-                                    deleted_entry_ranges_tx
-                                        .send((
-                                            deletion_range.0.map(ToString::to_string),
-                                            deletion_range.1.map(ToString::to_string),
-                                        ))
-                                        .await?;
-                                }
-                                saved_mtime = db_embedded_file.mtime;
-                                db_entries.next();
-                                break;
-                            }
-                            Ordering::Greater => {
-                                break;
-                            }
-                        },
-                        Err(_) => return Err(db_entries.next().unwrap().unwrap_err())?,
-                    }
-                }
-
-                if entry.mtime != saved_mtime {
-                    let handle = entries_being_indexed.insert(entry.id);
-                    updated_entries_tx.send((entry.clone(), handle)).await?;
-                }
-            }
-
-            if let Some(db_entry) = db_entries.next() {
-                let (db_path, _) = db_entry?;
-                deleted_entry_ranges_tx
-                    .send((Bound::Included(db_path.to_string()), Bound::Unbounded))
-                    .await?;
-            }
-
-            Ok(())
-        });
-
-        ScanEntries {
-            updated_entries: updated_entries_rx,
-            deleted_entry_ranges: deleted_entry_ranges_rx,
-            task,
-        }
-    }
-
-    fn scan_updated_entries(
-        &self,
-        worktree: Snapshot,
-        updated_entries: UpdatedEntriesSet,
-        cx: &App,
-    ) -> ScanEntries {
-        let (updated_entries_tx, updated_entries_rx) = channel::bounded(512);
-        let (deleted_entry_ranges_tx, deleted_entry_ranges_rx) = channel::bounded(128);
-        let entries_being_indexed = self.entry_ids_being_indexed.clone();
-        let task = cx.background_spawn(async move {
-            for (path, entry_id, status) in updated_entries.iter() {
-                match status {
-                    project::PathChange::Added
-                    | project::PathChange::Updated
-                    | project::PathChange::AddedOrUpdated => {
-                        if let Some(entry) = worktree.entry_for_id(*entry_id)
-                            && entry.is_file()
-                        {
-                            let handle = entries_being_indexed.insert(entry.id);
-                            updated_entries_tx.send((entry.clone(), handle)).await?;
-                        }
-                    }
-                    project::PathChange::Removed => {
-                        let db_path = db_key_for_path(path);
-                        deleted_entry_ranges_tx
-                            .send((Bound::Included(db_path.clone()), Bound::Included(db_path)))
-                            .await?;
-                    }
-                    project::PathChange::Loaded => {
-                        // Do nothing.
-                    }
-                }
-            }
-
-            Ok(())
-        });
-
-        ScanEntries {
-            updated_entries: updated_entries_rx,
-            deleted_entry_ranges: deleted_entry_ranges_rx,
-            task,
-        }
-    }
-
-    fn chunk_files(
-        &self,
-        worktree_abs_path: Arc<Path>,
-        entries: channel::Receiver<(Entry, IndexingEntryHandle)>,
-        cx: &App,
-    ) -> ChunkFiles {
-        let language_registry = self.language_registry.clone();
-        let fs = self.fs.clone();
-        let (chunked_files_tx, chunked_files_rx) = channel::bounded(2048);
-        let task = cx.spawn(async move |cx| {
-            cx.background_executor()
-                .scoped(|cx| {
-                    for _ in 0..cx.num_cpus() {
-                        cx.spawn(async {
-                            while let Ok((entry, handle)) = entries.recv().await {
-                                let entry_abs_path = worktree_abs_path.join(&entry.path);
-                                if let Some(text) = fs.load(&entry_abs_path).await.ok() {
-                                    let language = language_registry
-                                        .language_for_file_path(&entry.path)
-                                        .await
-                                        .ok();
-                                    let chunked_file = ChunkedFile {
-                                        chunks: chunking::chunk_text(
-                                            &text,
-                                            language.as_ref(),
-                                            &entry.path,
-                                        ),
-                                        handle,
-                                        path: entry.path,
-                                        mtime: entry.mtime,
-                                        text,
-                                    };
-
-                                    if chunked_files_tx.send(chunked_file).await.is_err() {
-                                        return;
-                                    }
-                                }
-                            }
-                        });
-                    }
-                })
-                .await;
-            Ok(())
-        });
-
-        ChunkFiles {
-            files: chunked_files_rx,
-            task,
-        }
-    }
-
-    pub fn embed_files(
-        embedding_provider: Arc<dyn EmbeddingProvider>,
-        chunked_files: channel::Receiver<ChunkedFile>,
-        cx: &App,
-    ) -> EmbedFiles {
-        let embedding_provider = embedding_provider.clone();
-        let (embedded_files_tx, embedded_files_rx) = channel::bounded(512);
-        let task = cx.background_spawn(async move {
-            let mut chunked_file_batches =
-                pin!(chunked_files.chunks_timeout(512, Duration::from_secs(2)));
-            while let Some(chunked_files) = chunked_file_batches.next().await {
-                // View the batch of files as a vec of chunks
-                // Flatten out to a vec of chunks that we can subdivide into batch sized pieces
-                // Once those are done, reassemble them back into the files in which they belong
-                // If any embeddings fail for a file, the entire file is discarded
-
-                let chunks: Vec<TextToEmbed> = chunked_files
-                    .iter()
-                    .flat_map(|file| {
-                        file.chunks.iter().map(|chunk| TextToEmbed {
-                            text: &file.text[chunk.range.clone()],
-                            digest: chunk.digest,
-                        })
-                    })
-                    .collect::<Vec<_>>();
-
-                let mut embeddings: Vec<Option<Embedding>> = Vec::new();
-                for embedding_batch in chunks.chunks(embedding_provider.batch_size()) {
-                    if let Some(batch_embeddings) =
-                        embedding_provider.embed(embedding_batch).await.log_err()
-                    {
-                        if batch_embeddings.len() == embedding_batch.len() {
-                            embeddings.extend(batch_embeddings.into_iter().map(Some));
-                            continue;
-                        }
-                        log::error!(
-                            "embedding provider returned unexpected embedding count {}, expected {}",
-                            batch_embeddings.len(), embedding_batch.len()
-                        );
-                    }
-
-                    embeddings.extend(iter::repeat(None).take(embedding_batch.len()));
-                }
-
-                let mut embeddings = embeddings.into_iter();
-                for chunked_file in chunked_files {
-                    let mut embedded_file = EmbeddedFile {
-                        path: chunked_file.path,
-                        mtime: chunked_file.mtime,
-                        chunks: Vec::new(),
-                    };
-
-                    let mut embedded_all_chunks = true;
-                    for (chunk, embedding) in
-                        chunked_file.chunks.into_iter().zip(embeddings.by_ref())
-                    {
-                        if let Some(embedding) = embedding {
-                            embedded_file
-                                .chunks
-                                .push(EmbeddedChunk { chunk, embedding });
-                        } else {
-                            embedded_all_chunks = false;
-                        }
-                    }
-
-                    if embedded_all_chunks {
-                        embedded_files_tx
-                            .send((embedded_file, chunked_file.handle))
-                            .await?;
-                    }
-                }
-            }
-            Ok(())
-        });
-
-        EmbedFiles {
-            files: embedded_files_rx,
-            task,
-        }
-    }
-
-    fn persist_embeddings(
-        &self,
-        deleted_entry_ranges: channel::Receiver<(Bound<String>, Bound<String>)>,
-        embedded_files: channel::Receiver<(EmbeddedFile, IndexingEntryHandle)>,
-        cx: &App,
-    ) -> Task<Result<()>> {
-        let db_connection = self.db_connection.clone();
-        let db = self.db;
-
-        cx.background_spawn(async move {
-            let mut deleted_entry_ranges = pin!(deleted_entry_ranges);
-            let mut embedded_files = pin!(embedded_files);
-            loop {
-                // Interleave deletions and persists of embedded files
-                futures::select_biased! {
-                    deletion_range = deleted_entry_ranges.next() => {
-                        if let Some(deletion_range) = deletion_range {
-                            let mut txn = db_connection.write_txn()?;
-                            let start = deletion_range.0.as_ref().map(|start| start.as_str());
-                            let end = deletion_range.1.as_ref().map(|end| end.as_str());
-                            log::debug!("deleting embeddings in range {:?}", &(start, end));
-                            db.delete_range(&mut txn, &(start, end))?;
-                            txn.commit()?;
-                        }
-                    },
-                    file = embedded_files.next() => {
-                        if let Some((file, _)) = file {
-                            let mut txn = db_connection.write_txn()?;
-                            log::debug!("saving embedding for file {:?}", file.path);
-                            let key = db_key_for_path(&file.path);
-                            db.put(&mut txn, &key, &file)?;
-                            txn.commit()?;
-                        }
-                    },
-                    complete => break,
-                }
-            }
-
-            Ok(())
-        })
-    }
-
-    pub fn paths(&self, cx: &App) -> Task<Result<Vec<Arc<Path>>>> {
-        let connection = self.db_connection.clone();
-        let db = self.db;
-        cx.background_spawn(async move {
-            let tx = connection
-                .read_txn()
-                .context("failed to create read transaction")?;
-            let result = db
-                .iter(&tx)?
-                .map(|entry| Ok(entry?.1.path))
-                .collect::<Result<Vec<Arc<Path>>>>();
-            drop(tx);
-            result
-        })
-    }
-
-    pub fn chunks_for_path(&self, path: Arc<Path>, cx: &App) -> Task<Result<Vec<EmbeddedChunk>>> {
-        let connection = self.db_connection.clone();
-        let db = self.db;
-        cx.background_spawn(async move {
-            let tx = connection
-                .read_txn()
-                .context("failed to create read transaction")?;
-            Ok(db
-                .get(&tx, &db_key_for_path(&path))?
-                .context("no such path")?
-                .chunks)
-        })
-    }
-}
-
-struct ScanEntries {
-    updated_entries: channel::Receiver<(Entry, IndexingEntryHandle)>,
-    deleted_entry_ranges: channel::Receiver<(Bound<String>, Bound<String>)>,
-    task: Task<Result<()>>,
-}
-
-struct ChunkFiles {
-    files: channel::Receiver<ChunkedFile>,
-    task: Task<Result<()>>,
-}
-
-pub struct ChunkedFile {
-    pub path: Arc<Path>,
-    pub mtime: Option<MTime>,
-    pub handle: IndexingEntryHandle,
-    pub text: String,
-    pub chunks: Vec<Chunk>,
-}
-
-pub struct EmbedFiles {
-    pub files: channel::Receiver<(EmbeddedFile, IndexingEntryHandle)>,
-    pub task: Task<Result<()>>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct EmbeddedFile {
-    pub path: Arc<Path>,
-    pub mtime: Option<MTime>,
-    pub chunks: Vec<EmbeddedChunk>,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct EmbeddedChunk {
-    pub chunk: Chunk,
-    pub embedding: Embedding,
-}
-
-fn db_key_for_path(path: &Arc<Path>) -> String {
-    path.to_string_lossy().replace('/', "\0")
-}
diff --git a/crates/semantic_index/src/indexing.rs b/crates/semantic_index/src/indexing.rs
deleted file mode 100644
index aca9504891d0f7baa0798389f92176a3c853bc6f..0000000000000000000000000000000000000000
--- a/crates/semantic_index/src/indexing.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-use collections::HashSet;
-use parking_lot::Mutex;
-use project::ProjectEntryId;
-use smol::channel;
-use std::sync::{Arc, Weak};
-
-/// The set of entries that are currently being indexed.
-pub struct IndexingEntrySet {
-    entry_ids: Mutex<HashSet<ProjectEntryId>>,
-    tx: channel::Sender<()>,
-}
-
-/// When dropped, removes the entry from the set of entries that are being indexed.
-#[derive(Clone)]
-pub(crate) struct IndexingEntryHandle {
-    entry_id: ProjectEntryId,
-    set: Weak<IndexingEntrySet>,
-}
-
-impl IndexingEntrySet {
-    pub fn new(tx: channel::Sender<()>) -> Self {
-        Self {
-            entry_ids: Default::default(),
-            tx,
-        }
-    }
-
-    pub fn insert(self: &Arc<Self>, entry_id: ProjectEntryId) -> IndexingEntryHandle {
-        self.entry_ids.lock().insert(entry_id);
-        self.tx.send_blocking(()).ok();
-        IndexingEntryHandle {
-            entry_id,
-            set: Arc::downgrade(self),
-        }
-    }
-
-    pub fn len(&self) -> usize {
-        self.entry_ids.lock().len()
-    }
-}
-
-impl Drop for IndexingEntryHandle {
-    fn drop(&mut self) {
-        if let Some(set) = self.set.upgrade() {
-            set.tx.send_blocking(()).ok();
-            set.entry_ids.lock().remove(&self.entry_id);
-        }
-    }
-}
diff --git a/crates/semantic_index/src/project_index.rs b/crates/semantic_index/src/project_index.rs
deleted file mode 100644
index 60b2770dd39b91b606b9c982c894bfc94952a179..0000000000000000000000000000000000000000
--- a/crates/semantic_index/src/project_index.rs
+++ /dev/null
@@ -1,548 +0,0 @@
-use crate::{
-    embedding::{EmbeddingProvider, TextToEmbed},
-    summary_index::FileSummary,
-    worktree_index::{WorktreeIndex, WorktreeIndexHandle},
-};
-use anyhow::{Context as _, Result, anyhow};
-use collections::HashMap;
-use fs::Fs;
-use futures::FutureExt;
-use gpui::{
-    App, AppContext as _, Context, Entity, EntityId, EventEmitter, Subscription, Task, WeakEntity,
-};
-use language::LanguageRegistry;
-use log;
-use project::{Project, Worktree, WorktreeId};
-use serde::{Deserialize, Serialize};
-use smol::channel;
-use std::{
-    cmp::Ordering,
-    future::Future,
-    num::NonZeroUsize,
-    ops::{Range, RangeInclusive},
-    path::{Path, PathBuf},
-    sync::Arc,
-};
-use util::ResultExt;
-
-#[derive(Debug)]
-pub struct SearchResult {
-    pub worktree: Entity<Worktree>,
-    pub path: Arc<Path>,
-    pub range: Range<usize>,
-    pub score: f32,
-    pub query_index: usize,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub struct LoadedSearchResult {
-    pub path: Arc<Path>,
-    pub full_path: PathBuf,
-    pub excerpt_content: String,
-    pub row_range: RangeInclusive<u32>,
-    pub query_index: usize,
-}
-
-pub struct WorktreeSearchResult {
-    pub worktree_id: WorktreeId,
-    pub path: Arc<Path>,
-    pub range: Range<usize>,
-    pub query_index: usize,
-    pub score: f32,
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
-pub enum Status {
-    Idle,
-    Loading,
-    Scanning { remaining_count: NonZeroUsize },
-}
-
-pub struct ProjectIndex {
-    db_connection: heed::Env,
-    project: WeakEntity<Project>,
-    worktree_indices: HashMap<EntityId, WorktreeIndexHandle>,
-    language_registry: Arc<LanguageRegistry>,
-    fs: Arc<dyn Fs>,
-    last_status: Status,
-    status_tx: channel::Sender<()>,
-    embedding_provider: Arc<dyn EmbeddingProvider>,
-    _maintain_status: Task<()>,
-    _subscription: Subscription,
-}
-
-impl ProjectIndex {
-    pub fn new(
-        project: Entity<Project>,
-        db_connection: heed::Env,
-        embedding_provider: Arc<dyn EmbeddingProvider>,
-        cx: &mut Context<Self>,
-    ) -> Self {
-        let language_registry = project.read(cx).languages().clone();
-        let fs = project.read(cx).fs().clone();
-        let (status_tx, status_rx) = channel::unbounded();
-        let mut this = ProjectIndex {
-            db_connection,
-            project: project.downgrade(),
-            worktree_indices: HashMap::default(),
-            language_registry,
-            fs,
-            status_tx,
-            last_status: Status::Idle,
-            embedding_provider,
-            _subscription: cx.subscribe(&project, Self::handle_project_event),
-            _maintain_status: cx.spawn(async move |this, cx| {
-                while status_rx.recv().await.is_ok() {
-                    if this.update(cx, |this, cx| this.update_status(cx)).is_err() {
-                        break;
-                    }
-                }
-            }),
-        };
-        this.update_worktree_indices(cx);
-        this
-    }
-
-    pub fn status(&self) -> Status {
-        self.last_status
-    }
-
-    pub fn project(&self) -> WeakEntity<Project> {
-        self.project.clone()
-    }
-
-    pub fn fs(&self) -> Arc<dyn Fs> {
-        self.fs.clone()
-    }
-
-    fn handle_project_event(
-        &mut self,
-        _: Entity<Project>,
-        event: &project::Event,
-        cx: &mut Context<Self>,
-    ) {
-        match event {
-            project::Event::WorktreeAdded(_) | project::Event::WorktreeRemoved(_) => {
-                self.update_worktree_indices(cx);
-            }
-            _ => {}
-        }
-    }
-
-    fn update_worktree_indices(&mut self, cx: &mut Context<Self>) {
-        let Some(project) = self.project.upgrade() else {
-            return;
-        };
-
-        let worktrees = project
-            .read(cx)
-            .visible_worktrees(cx)
-            .filter_map(|worktree| {
-                if worktree.read(cx).is_local() {
-                    Some((worktree.entity_id(), worktree))
-                } else {
-                    None
-                }
-            })
-            .collect::<HashMap<_, _>>();
-
-        self.worktree_indices
-            .retain(|worktree_id, _| worktrees.contains_key(worktree_id));
-        for (worktree_id, worktree) in worktrees {
-            self.worktree_indices.entry(worktree_id).or_insert_with(|| {
-                let worktree_index = WorktreeIndex::load(
-                    worktree.clone(),
-                    self.db_connection.clone(),
-                    self.language_registry.clone(),
-                    self.fs.clone(),
-                    self.status_tx.clone(),
-                    self.embedding_provider.clone(),
-                    cx,
-                );
-
-                let load_worktree = cx.spawn(async move |this, cx| {
-                    let result = match worktree_index.await {
-                        Ok(worktree_index) => {
-                            this.update(cx, |this, _| {
-                                this.worktree_indices.insert(
-                                    worktree_id,
-                                    WorktreeIndexHandle::Loaded {
-                                        index: worktree_index.clone(),
-                                    },
-                                );
-                            })?;
-                            Ok(worktree_index)
-                        }
-                        Err(error) => {
-                            this.update(cx, |this, _cx| {
-                                this.worktree_indices.remove(&worktree_id)
-                            })?;
-                            Err(Arc::new(error))
-                        }
-                    };
-
-                    this.update(cx, |this, cx| this.update_status(cx))?;
-
-                    result
-                });
-
-                WorktreeIndexHandle::Loading {
-                    index: load_worktree.shared(),
-                }
-            });
-        }
-
-        self.update_status(cx);
-    }
-
-    fn update_status(&mut self, cx: &mut Context<Self>) {
-        let mut indexing_count = 0;
-        let mut any_loading = false;
-
-        for index in self.worktree_indices.values_mut() {
-            match index {
-                WorktreeIndexHandle::Loading { .. } => {
-                    any_loading = true;
-                    break;
-                }
-                WorktreeIndexHandle::Loaded { index, .. } => {
-                    indexing_count += index.read(cx).entry_ids_being_indexed().len();
-                }
-            }
-        }
-
-        let status = if any_loading {
-            Status::Loading
-        } else if let Some(remaining_count) = NonZeroUsize::new(indexing_count) {
-            Status::Scanning { remaining_count }
-        } else {
-            Status::Idle
-        };
-
-        if status != self.last_status {
-            self.last_status = status;
-            cx.emit(status);
-        }
-    }
-
-    pub fn search(
-        &self,
-        queries: Vec<String>,
-        limit: usize,
-        cx: &App,
-    ) -> Task<Result<Vec<SearchResult>>> {
-        let (chunks_tx, chunks_rx) = channel::bounded(1024);
-        let mut worktree_scan_tasks = Vec::new();
-        for worktree_index in self.worktree_indices.values() {
-            let worktree_index = worktree_index.clone();
-            let chunks_tx = chunks_tx.clone();
-            worktree_scan_tasks.push(cx.spawn(async move |cx| {
-                let index = match worktree_index {
-                    WorktreeIndexHandle::Loading { index } => {
-                        index.clone().await.map_err(|error| anyhow!(error))?
-                    }
-                    WorktreeIndexHandle::Loaded { index } => index.clone(),
-                };
-
-                index
-                    .read_with(cx, |index, cx| {
-                        let worktree_id = index.worktree().read(cx).id();
-                        let db_connection = index.db_connection().clone();
-                        let db = *index.embedding_index().db();
-                        cx.background_spawn(async move {
-                            let txn = db_connection
-                                .read_txn()
-                                .context("failed to create read transaction")?;
-                            let db_entries = db.iter(&txn).context("failed to iterate database")?;
-                            for db_entry in db_entries {
-                                let (_key, db_embedded_file) = db_entry?;
-                                for chunk in db_embedded_file.chunks {
-                                    chunks_tx
-                                        .send((worktree_id, db_embedded_file.path.clone(), chunk))
-                                        .await?;
-                                }
-                            }
-                            anyhow::Ok(())
-                        })
-                    })?
-                    .await
-            }));
-        }
-        drop(chunks_tx);
-
-        let project = self.project.clone();
-        let embedding_provider = self.embedding_provider.clone();
-        cx.spawn(async move |cx| {
-            #[cfg(debug_assertions)]
-            let embedding_query_start = std::time::Instant::now();
-            log::info!("Searching for {queries:?}");
-            let queries: Vec<TextToEmbed> = queries
-                .iter()
-                .map(|s| TextToEmbed::new(s.as_str()))
-                .collect();
-
-            let query_embeddings = embedding_provider.embed(&queries[..]).await?;
-            anyhow::ensure!(
-                query_embeddings.len() == queries.len(),
-                "The number of query embeddings does not match the number of queries"
-            );
-
-            let mut results_by_worker = Vec::new();
-            for _ in 0..cx.background_executor().num_cpus() {
-                results_by_worker.push(Vec::<WorktreeSearchResult>::new());
-            }
-
-            #[cfg(debug_assertions)]
-            let search_start = std::time::Instant::now();
-            cx.background_executor()
-                .scoped(|cx| {
-                    for results in results_by_worker.iter_mut() {
-                        cx.spawn(async {
-                            while let Ok((worktree_id, path, chunk)) = chunks_rx.recv().await {
-                                let (score, query_index) =
-                                    chunk.embedding.similarity(&query_embeddings);
-
-                                let ix = match results.binary_search_by(|probe| {
-                                    score.partial_cmp(&probe.score).unwrap_or(Ordering::Equal)
-                                }) {
-                                    Ok(ix) | Err(ix) => ix,
-                                };
-                                if ix < limit {
-                                    results.insert(
-                                        ix,
-                                        WorktreeSearchResult {
-                                            worktree_id,
-                                            path: path.clone(),
-                                            range: chunk.chunk.range.clone(),
-                                            query_index,
-                                            score,
-                                        },
-                                    );
-                                    if results.len() > limit {
-                                        results.pop();
-                                    }
-                                }
-                            }
-                        });
-                    }
-                })
-                .await;
-
-            for scan_task in futures::future::join_all(worktree_scan_tasks).await {
-                scan_task.log_err();
-            }
-
-            project.read_with(cx, |project, cx| {
-                let mut search_results = Vec::with_capacity(results_by_worker.len() * limit);
-                for worker_results in results_by_worker {
-                    search_results.extend(worker_results.into_iter().filter_map(|result| {
-                        Some(SearchResult {
-                            worktree: project.worktree_for_id(result.worktree_id, cx)?,
-                            path: result.path,
-                            range: result.range,
-                            score: result.score,
-                            query_index: result.query_index,
-                        })
-                    }));
-                }
-                search_results.sort_unstable_by(|a, b| {
-                    b.score.partial_cmp(&a.score).unwrap_or(Ordering::Equal)
-                });
-                search_results.truncate(limit);
-
-                #[cfg(debug_assertions)]
-                {
-                    let search_elapsed = search_start.elapsed();
-                    log::debug!(
-                        "searched {} entries in {:?}",
-                        search_results.len(),
-                        search_elapsed
-                    );
-                    let embedding_query_elapsed = embedding_query_start.elapsed();
-                    log::debug!("embedding query took {:?}", embedding_query_elapsed);
-                }
-
-                search_results
-            })
-        })
-    }
-
-    #[cfg(test)]
-    pub fn path_count(&self, cx: &App) -> Result<u64> {
-        let mut result = 0;
-        for worktree_index in self.worktree_indices.values() {
-            if let WorktreeIndexHandle::Loaded { index, .. } = worktree_index {
-                result += index.read(cx).path_count()?;
-            }
-        }
-        Ok(result)
-    }
-
-    pub(crate) fn worktree_index(
-        &self,
-        worktree_id: WorktreeId,
-        cx: &App,
-    ) -> Option<Entity<WorktreeIndex>> {
-        for index in self.worktree_indices.values() {
-            if let WorktreeIndexHandle::Loaded { index, .. } = index
-                && index.read(cx).worktree().read(cx).id() == worktree_id
-            {
-                return Some(index.clone());
-            }
-        }
-        None
-    }
-
-    pub(crate) fn worktree_indices(&self, cx: &App) -> Vec<Entity<WorktreeIndex>> {
-        let mut result = self
-            .worktree_indices
-            .values()
-            .filter_map(|index| {
-                if let WorktreeIndexHandle::Loaded { index, .. } = index {
-                    Some(index.clone())
-                } else {
-                    None
-                }
-            })
-            .collect::<Vec<_>>();
-        result.sort_by_key(|index| index.read(cx).worktree().read(cx).id());
-        result
-    }
-
-    pub fn all_summaries(&self, cx: &App) -> Task<Result<Vec<FileSummary>>> {
-        let (summaries_tx, summaries_rx) = channel::bounded(1024);
-        let mut worktree_scan_tasks = Vec::new();
-        for worktree_index in self.worktree_indices.values() {
-            let worktree_index = worktree_index.clone();
-            let summaries_tx: channel::Sender<(String, String)> = summaries_tx.clone();
-            worktree_scan_tasks.push(cx.spawn(async move |cx| {
-                let index = match worktree_index {
-                    WorktreeIndexHandle::Loading { index } => {
-                        index.clone().await.map_err(|error| anyhow!(error))?
-                    }
-                    WorktreeIndexHandle::Loaded { index } => index.clone(),
-                };
-
-                index
-                    .read_with(cx, |index, cx| {
-                        let db_connection = index.db_connection().clone();
-                        let summary_index = index.summary_index();
-                        let file_digest_db = summary_index.file_digest_db();
-                        let summary_db = summary_index.summary_db();
-
-                        cx.background_spawn(async move {
-                            let txn = db_connection
-                                .read_txn()
-                                .context("failed to create db read transaction")?;
-                            let db_entries = file_digest_db
-                                .iter(&txn)
-                                .context("failed to iterate database")?;
-                            for db_entry in db_entries {
-                                let (file_path, db_file) = db_entry?;
-
-                                match summary_db.get(&txn, &db_file.digest) {
-                                    Ok(opt_summary) => {
-                                        // Currently, we only use summaries we already have. If the file hasn't been
-                                        // summarized yet, then we skip it and don't include it in the inferred context.
-                                        // If we want to do just-in-time summarization, this would be the place to do it!
-                                        if let Some(summary) = opt_summary {
-                                            summaries_tx
-                                                .send((file_path.to_string(), summary.to_string()))
-                                                .await?;
-                                        } else {
-                                            log::warn!("No summary found for {:?}", &db_file);
-                                        }
-                                    }
-                                    Err(err) => {
-                                        log::error!(
-                                            "Error reading from summary database: {:?}",
-                                            err
-                                        );
-                                    }
-                                }
-                            }
-                            anyhow::Ok(())
-                        })
-                    })?
-                    .await
-            }));
-        }
-        drop(summaries_tx);
-
-        let project = self.project.clone();
-        cx.spawn(async move |cx| {
-            let mut results_by_worker = Vec::new();
-            for _ in 0..cx.background_executor().num_cpus() {
-                results_by_worker.push(Vec::<FileSummary>::new());
-            }
-
-            cx.background_executor()
-                .scoped(|cx| {
-                    for results in results_by_worker.iter_mut() {
-                        cx.spawn(async {
-                            while let Ok((filename, summary)) = summaries_rx.recv().await {
-                                results.push(FileSummary { filename, summary });
-                            }
-                        });
-                    }
-                })
-                .await;
-
-            for scan_task in futures::future::join_all(worktree_scan_tasks).await {
-                scan_task.log_err();
-            }
-
-            project.read_with(cx, |_project, _cx| {
-                results_by_worker.into_iter().flatten().collect()
-            })
-        })
-    }
-
-    /// Empty out the backlogs of all the worktrees in the project
-    pub fn flush_summary_backlogs(&self, cx: &App) -> impl Future<Output = ()> {
-        let flush_start = std::time::Instant::now();
-
-        futures::future::join_all(self.worktree_indices.values().map(|worktree_index| {
-            let worktree_index = worktree_index.clone();
-
-            cx.spawn(async move |cx| {
-                let index = match worktree_index {
-                    WorktreeIndexHandle::Loading { index } => {
-                        index.clone().await.map_err(|error| anyhow!(error))?
-                    }
-                    WorktreeIndexHandle::Loaded { index } => index.clone(),
-                };
-                let worktree_abs_path =
-                    cx.update(|cx| index.read(cx).worktree().read(cx).abs_path())?;
-
-                index
-                    .read_with(cx, |index, cx| {
-                        cx.background_spawn(
-                            index.summary_index().flush_backlog(worktree_abs_path, cx),
-                        )
-                    })?
-                    .await
-            })
-        }))
-        .map(move |results| {
-            // Log any errors, but don't block the user. These summaries are supposed to
-            // improve quality by providing extra context, but they aren't hard requirements!
-            for result in results {
-                if let Err(err) = result {
-                    log::error!("Error flushing summary backlog: {:?}", err);
-                }
-            }
-
-            log::info!("Summary backlog flushed in {:?}", flush_start.elapsed());
-        })
-    }
-
-    pub fn remaining_summaries(&self, cx: &mut Context<Self>) -> usize {
-        self.worktree_indices(cx)
-            .iter()
-            .map(|index| index.read(cx).summary_index().backlog_len())
-            .sum()
-    }
-}
-
-impl EventEmitter<Status> for ProjectIndex {}
diff --git a/crates/semantic_index/src/project_index_debug_view.rs b/crates/semantic_index/src/project_index_debug_view.rs
deleted file mode 100644
index 8d6a49c45caf336c03fe0a2b62ecbca9e079fc65..0000000000000000000000000000000000000000
--- a/crates/semantic_index/src/project_index_debug_view.rs
+++ /dev/null
@@ -1,306 +0,0 @@
-use crate::ProjectIndex;
-use gpui::{
-    AnyElement, App, CursorStyle, Entity, EventEmitter, FocusHandle, Focusable, IntoElement,
-    ListOffset, ListState, MouseMoveEvent, Render, UniformListScrollHandle, canvas, div, list,
-    uniform_list,
-};
-use project::WorktreeId;
-use settings::Settings;
-use std::{ops::Range, path::Path, sync::Arc};
-use theme::ThemeSettings;
-use ui::prelude::*;
-use workspace::item::Item;
-
-pub struct ProjectIndexDebugView {
-    index: Entity<ProjectIndex>,
-    rows: Vec<Row>,
-    selected_path: Option<PathState>,
-    hovered_row_ix: Option<usize>,
-    focus_handle: FocusHandle,
-    list_scroll_handle: UniformListScrollHandle,
-    _subscription: gpui::Subscription,
-}
-
-struct PathState {
-    path: Arc<Path>,
-    chunks: Vec<SharedString>,
-    list_state: ListState,
-}
-
-enum Row {
-    Worktree(Arc<Path>),
-    Entry(WorktreeId, Arc<Path>),
-}
-
-impl ProjectIndexDebugView {
-    pub fn new(index: Entity<ProjectIndex>, window: &mut Window, cx: &mut Context<Self>) -> Self {
-        let mut this = Self {
-            rows: Vec::new(),
-            list_scroll_handle: UniformListScrollHandle::new(),
-            selected_path: None,
-            hovered_row_ix: None,
-            focus_handle: cx.focus_handle(),
-            _subscription: cx.subscribe_in(&index, window, |this, _, _, window, cx| {
-                this.update_rows(window, cx)
-            }),
-            index,
-        };
-        this.update_rows(window, cx);
-        this
-    }
-
-    fn update_rows(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        let worktree_indices = self.index.read(cx).worktree_indices(cx);
-        cx.spawn_in(window, async move |this, cx| {
-            let mut rows = Vec::new();
-
-            for index in worktree_indices {
-                let (root_path, worktree_id, worktree_paths) =
-                    index.read_with(cx, |index, cx| {
-                        let worktree = index.worktree().read(cx);
-                        (
-                            worktree.abs_path(),
-                            worktree.id(),
-                            index.embedding_index().paths(cx),
-                        )
-                    })?;
-                rows.push(Row::Worktree(root_path));
-                rows.extend(
-                    worktree_paths
-                        .await?
-                        .into_iter()
-                        .map(|path| Row::Entry(worktree_id, path)),
-                );
-            }
-
-            this.update(cx, |this, cx| {
-                this.rows = rows;
-                cx.notify();
-            })
-        })
-        .detach();
-    }
-
-    fn handle_path_click(
-        &mut self,
-        worktree_id: WorktreeId,
-        file_path: Arc<Path>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Option<()> {
-        let project_index = self.index.read(cx);
-        let fs = project_index.fs().clone();
-        let worktree_index = project_index.worktree_index(worktree_id, cx)?.read(cx);
-        let root_path = worktree_index.worktree().read(cx).abs_path();
-        let chunks = worktree_index
-            .embedding_index()
-            .chunks_for_path(file_path.clone(), cx);
-
-        cx.spawn_in(window, async move |this, cx| {
-            let chunks = chunks.await?;
-            let content = fs.load(&root_path.join(&file_path)).await?;
-            let chunks = chunks
-                .into_iter()
-                .map(|chunk| {
-                    let mut start = chunk.chunk.range.start.min(content.len());
-                    let mut end = chunk.chunk.range.end.min(content.len());
-                    while !content.is_char_boundary(start) {
-                        start += 1;
-                    }
-                    while !content.is_char_boundary(end) {
-                        end -= 1;
-                    }
-                    content[start..end].to_string().into()
-                })
-                .collect::<Vec<_>>();
-
-            this.update(cx, |this, cx| {
-                this.selected_path = Some(PathState {
-                    path: file_path,
-                    list_state: ListState::new(chunks.len(), gpui::ListAlignment::Top, px(100.)),
-                    chunks,
-                });
-                cx.notify();
-            })
-        })
-        .detach();
-        None
-    }
-
-    fn render_chunk(&mut self, ix: usize, cx: &mut Context<Self>) -> AnyElement {
-        let buffer_font = ThemeSettings::get_global(cx).buffer_font.clone();
-        let Some(state) = &self.selected_path else {
-            return div().into_any();
-        };
-
-        let colors = cx.theme().colors();
-        let chunk = &state.chunks[ix];
-
-        div()
-            .text_ui(cx)
-            .w_full()
-            .font(buffer_font)
-            .child(
-                h_flex()
-                    .justify_between()
-                    .child(format!(
-                        "chunk {} of {}. length: {}",
-                        ix + 1,
-                        state.chunks.len(),
-                        chunk.len(),
-                    ))
-                    .child(
-                        h_flex()
-                            .child(
-                                Button::new(("prev", ix), "prev")
-                                    .disabled(ix == 0)
-                                    .on_click(cx.listener(move |this, _, _, _| {
-                                        this.scroll_to_chunk(ix.saturating_sub(1))
-                                    })),
-                            )
-                            .child(
-                                Button::new(("next", ix), "next")
-                                    .disabled(ix + 1 == state.chunks.len())
-                                    .on_click(cx.listener(move |this, _, _, _| {
-                                        this.scroll_to_chunk(ix + 1)
-                                    })),
-                            ),
-                    ),
-            )
-            .child(
-                div()
-                    .bg(colors.editor_background)
-                    .text_xs()
-                    .child(chunk.clone()),
-            )
-            .into_any_element()
-    }
-
-    fn scroll_to_chunk(&mut self, ix: usize) {
-        if let Some(state) = self.selected_path.as_mut() {
-            state.list_state.scroll_to(ListOffset {
-                item_ix: ix,
-                offset_in_item: px(0.),
-            })
-        }
-    }
-}
-
-impl Render for ProjectIndexDebugView {
-    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        if let Some(selected_path) = self.selected_path.as_ref() {
-            v_flex()
-                .child(
-                    div()
-                        .id("selected-path-name")
-                        .child(
-                            h_flex()
-                                .justify_between()
-                                .child(selected_path.path.to_string_lossy().to_string())
-                                .child("x"),
-                        )
-                        .border_b_1()
-                        .border_color(cx.theme().colors().border)
-                        .cursor(CursorStyle::PointingHand)
-                        .on_click(cx.listener(|this, _, _, cx| {
-                            this.selected_path.take();
-                            cx.notify();
-                        })),
-                )
-                .child(
-                    list(
-                        selected_path.list_state.clone(),
-                        cx.processor(|this, ix, _, cx| this.render_chunk(ix, cx)),
-                    )
-                    .size_full(),
-                )
-                .size_full()
-                .into_any_element()
-        } else {
-            let mut list = uniform_list(
-                "ProjectIndexDebugView",
-                self.rows.len(),
-                cx.processor(move |this, range: Range<usize>, _, cx| {
-                    this.rows[range]
-                        .iter()
-                        .enumerate()
-                        .map(|(ix, row)| match row {
-                            Row::Worktree(root_path) => div()
-                                .id(ix)
-                                .child(Label::new(root_path.to_string_lossy().to_string())),
-                            Row::Entry(worktree_id, file_path) => div()
-                                .id(ix)
-                                .pl_8()
-                                .child(Label::new(file_path.to_string_lossy().to_string()))
-                                .on_mouse_move(cx.listener(
-                                    move |this, _: &MouseMoveEvent, _, cx| {
-                                        if this.hovered_row_ix != Some(ix) {
-                                            this.hovered_row_ix = Some(ix);
-                                            cx.notify();
-                                        }
-                                    },
-                                ))
-                                .cursor(CursorStyle::PointingHand)
-                                .on_click(cx.listener({
-                                    let worktree_id = *worktree_id;
-                                    let file_path = file_path.clone();
-                                    move |this, _, window, cx| {
-                                        this.handle_path_click(
-                                            worktree_id,
-                                            file_path.clone(),
-                                            window,
-                                            cx,
-                                        );
-                                    }
-                                })),
-                        })
-                        .collect()
-                }),
-            )
-            .track_scroll(self.list_scroll_handle.clone())
-            .size_full()
-            .text_bg(cx.theme().colors().background)
-            .into_any_element();
-
-            canvas(
-                move |bounds, window, cx| {
-                    list.prepaint_as_root(bounds.origin, bounds.size.into(), window, cx);
-                    list
-                },
-                |_, mut list, window, cx| {
-                    list.paint(window, cx);
-                },
-            )
-            .size_full()
-            .into_any_element()
-        }
-    }
-}
-
-impl EventEmitter<()> for ProjectIndexDebugView {}
-
-impl Item for ProjectIndexDebugView {
-    type Event = ();
-
-    fn tab_content_text(&self, _detail: usize, _cx: &App) -> SharedString {
-        "Project Index (Debug)".into()
-    }
-
-    fn clone_on_split(
-        &self,
-        _: Option<workspace::WorkspaceId>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Option<Entity<Self>>
-    where
-        Self: Sized,
-    {
-        Some(cx.new(|cx| Self::new(self.index.clone(), window, cx)))
-    }
-}
-
-impl Focusable for ProjectIndexDebugView {
-    fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
-        self.focus_handle.clone()
-    }
-}
diff --git a/crates/semantic_index/src/semantic_index.rs b/crates/semantic_index/src/semantic_index.rs
deleted file mode 100644
index 439791047a282771f94982c5bad4c690df497cc4..0000000000000000000000000000000000000000
--- a/crates/semantic_index/src/semantic_index.rs
+++ /dev/null
@@ -1,632 +0,0 @@
-mod chunking;
-mod embedding;
-mod embedding_index;
-mod indexing;
-mod project_index;
-mod project_index_debug_view;
-mod summary_backlog;
-mod summary_index;
-mod worktree_index;
-
-use anyhow::{Context as _, Result};
-use collections::HashMap;
-use fs::Fs;
-use gpui::{App, AppContext as _, AsyncApp, BorrowAppContext, Context, Entity, Global, WeakEntity};
-use language::LineEnding;
-use project::{Project, Worktree};
-use std::{
-    cmp::Ordering,
-    path::{Path, PathBuf},
-    sync::Arc,
-};
-use util::ResultExt as _;
-use workspace::Workspace;
-
-pub use embedding::*;
-pub use project_index::{LoadedSearchResult, ProjectIndex, SearchResult, Status};
-pub use project_index_debug_view::ProjectIndexDebugView;
-pub use summary_index::FileSummary;
-
-pub struct SemanticDb {
-    embedding_provider: Arc<dyn EmbeddingProvider>,
-    db_connection: Option<heed::Env>,
-    project_indices: HashMap<WeakEntity<Project>, Entity<ProjectIndex>>,
-}
-
-impl Global for SemanticDb {}
-
-impl SemanticDb {
-    pub async fn new(
-        db_path: PathBuf,
-        embedding_provider: Arc<dyn EmbeddingProvider>,
-        cx: &mut AsyncApp,
-    ) -> Result<Self> {
-        let db_connection = cx
-            .background_spawn(async move {
-                std::fs::create_dir_all(&db_path)?;
-                unsafe {
-                    heed::EnvOpenOptions::new()
-                        .map_size(1024 * 1024 * 1024)
-                        .max_dbs(3000)
-                        .open(db_path)
-                }
-            })
-            .await
-            .context("opening database connection")?;
-
-        cx.update(|cx| {
-            cx.observe_new(
-                |workspace: &mut Workspace, _window, cx: &mut Context<Workspace>| {
-                    let project = workspace.project().clone();
-
-                    if cx.has_global::<SemanticDb>() {
-                        cx.update_global::<SemanticDb, _>(|this, cx| {
-                            this.create_project_index(project, cx);
-                        })
-                    } else {
-                        log::info!("No SemanticDb, skipping project index")
-                    }
-                },
-            )
-            .detach();
-        })
-        .ok();
-
-        Ok(SemanticDb {
-            db_connection: Some(db_connection),
-            embedding_provider,
-            project_indices: HashMap::default(),
-        })
-    }
-
-    pub async fn load_results(
-        mut results: Vec<SearchResult>,
-        fs: &Arc<dyn Fs>,
-        cx: &AsyncApp,
-    ) -> Result<Vec<LoadedSearchResult>> {
-        let mut max_scores_by_path = HashMap::<_, (f32, usize)>::default();
-        for result in &results {
-            let (score, query_index) = max_scores_by_path
-                .entry((result.worktree.clone(), result.path.clone()))
-                .or_default();
-            if result.score > *score {
-                *score = result.score;
-                *query_index = result.query_index;
-            }
-        }
-
-        results.sort_by(|a, b| {
-            let max_score_a = max_scores_by_path[&(a.worktree.clone(), a.path.clone())].0;
-            let max_score_b = max_scores_by_path[&(b.worktree.clone(), b.path.clone())].0;
-            max_score_b
-                .partial_cmp(&max_score_a)
-                .unwrap_or(Ordering::Equal)
-                .then_with(|| a.worktree.entity_id().cmp(&b.worktree.entity_id()))
-                .then_with(|| a.path.cmp(&b.path))
-                .then_with(|| a.range.start.cmp(&b.range.start))
-        });
-
-        let mut last_loaded_file: Option<(Entity<Worktree>, Arc<Path>, PathBuf, String)> = None;
-        let mut loaded_results = Vec::<LoadedSearchResult>::new();
-        for result in results {
-            let full_path;
-            let file_content;
-            if let Some(last_loaded_file) =
-                last_loaded_file
-                    .as_ref()
-                    .filter(|(last_worktree, last_path, _, _)| {
-                        last_worktree == &result.worktree && last_path == &result.path
-                    })
-            {
-                full_path = last_loaded_file.2.clone();
-                file_content = &last_loaded_file.3;
-            } else {
-                let output = result.worktree.read_with(cx, |worktree, _cx| {
-                    let entry_abs_path = worktree.abs_path().join(&result.path);
-                    let mut entry_full_path = PathBuf::from(worktree.root_name());
-                    entry_full_path.push(&result.path);
-                    let file_content = async {
-                        let entry_abs_path = entry_abs_path;
-                        fs.load(&entry_abs_path).await
-                    };
-                    (entry_full_path, file_content)
-                })?;
-                full_path = output.0;
-                let Some(content) = output.1.await.log_err() else {
-                    continue;
-                };
-                last_loaded_file = Some((
-                    result.worktree.clone(),
-                    result.path.clone(),
-                    full_path.clone(),
-                    content,
-                ));
-                file_content = &last_loaded_file.as_ref().unwrap().3;
-            };
-
-            let query_index = max_scores_by_path[&(result.worktree.clone(), result.path.clone())].1;
-
-            let mut range_start = result.range.start.min(file_content.len());
-            let mut range_end = result.range.end.min(file_content.len());
-            while !file_content.is_char_boundary(range_start) {
-                range_start += 1;
-            }
-            while !file_content.is_char_boundary(range_end) {
-                range_end += 1;
-            }
-
-            let start_row = file_content[0..range_start].matches('\n').count() as u32;
-            let mut end_row = file_content[0..range_end].matches('\n').count() as u32;
-            let start_line_byte_offset = file_content[0..range_start]
-                .rfind('\n')
-                .map(|pos| pos + 1)
-                .unwrap_or_default();
-            let mut end_line_byte_offset = range_end;
-            if file_content[..end_line_byte_offset].ends_with('\n') {
-                end_row -= 1;
-            } else {
-                end_line_byte_offset = file_content[range_end..]
-                    .find('\n')
-                    .map(|pos| range_end + pos + 1)
-                    .unwrap_or_else(|| file_content.len());
-            }
-            let mut excerpt_content =
-                file_content[start_line_byte_offset..end_line_byte_offset].to_string();
-            LineEnding::normalize(&mut excerpt_content);
-
-            if let Some(prev_result) = loaded_results.last_mut()
-                && prev_result.full_path == full_path
-                && *prev_result.row_range.end() + 1 == start_row
-            {
-                prev_result.row_range = *prev_result.row_range.start()..=end_row;
-                prev_result.excerpt_content.push_str(&excerpt_content);
-                continue;
-            }
-
-            loaded_results.push(LoadedSearchResult {
-                path: result.path,
-                full_path,
-                excerpt_content,
-                row_range: start_row..=end_row,
-                query_index,
-            });
-        }
-
-        for result in &mut loaded_results {
-            while result.excerpt_content.ends_with("\n\n") {
-                result.excerpt_content.pop();
-                result.row_range =
-                    *result.row_range.start()..=result.row_range.end().saturating_sub(1)
-            }
-        }
-
-        Ok(loaded_results)
-    }
-
-    pub fn project_index(
-        &mut self,
-        project: Entity<Project>,
-        _cx: &mut App,
-    ) -> Option<Entity<ProjectIndex>> {
-        self.project_indices.get(&project.downgrade()).cloned()
-    }
-
-    pub fn remaining_summaries(
-        &self,
-        project: &WeakEntity<Project>,
-        cx: &mut App,
-    ) -> Option<usize> {
-        self.project_indices.get(project).map(|project_index| {
-            project_index.update(cx, |project_index, cx| {
-                project_index.remaining_summaries(cx)
-            })
-        })
-    }
-
-    pub fn create_project_index(
-        &mut self,
-        project: Entity<Project>,
-        cx: &mut App,
-    ) -> Entity<ProjectIndex> {
-        let project_index = cx.new(|cx| {
-            ProjectIndex::new(
-                project.clone(),
-                self.db_connection.clone().unwrap(),
-                self.embedding_provider.clone(),
-                cx,
-            )
-        });
-
-        let project_weak = project.downgrade();
-        self.project_indices
-            .insert(project_weak.clone(), project_index.clone());
-
-        cx.observe_release(&project, move |_, cx| {
-            if cx.has_global::<SemanticDb>() {
-                cx.update_global::<SemanticDb, _>(|this, _| {
-                    this.project_indices.remove(&project_weak);
-                })
-            }
-        })
-        .detach();
-
-        project_index
-    }
-}
-
-impl Drop for SemanticDb {
-    fn drop(&mut self) {
-        self.db_connection.take().unwrap().prepare_for_closing();
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use chunking::Chunk;
-    use embedding_index::{ChunkedFile, EmbeddingIndex};
-    use feature_flags::FeatureFlagAppExt;
-    use fs::FakeFs;
-    use futures::{FutureExt, future::BoxFuture};
-    use gpui::TestAppContext;
-    use indexing::IndexingEntrySet;
-    use language::language_settings::AllLanguageSettings;
-    use project::{Project, ProjectEntryId};
-    use serde_json::json;
-    use settings::SettingsStore;
-    use smol::channel;
-    use std::{future, path::Path, sync::Arc};
-    use util::path;
-
-    fn init_test(cx: &mut TestAppContext) {
-        zlog::init_test();
-
-        cx.update(|cx| {
-            let store = SettingsStore::test(cx);
-            cx.set_global(store);
-            language::init(cx);
-            cx.update_flags(false, vec![]);
-            Project::init_settings(cx);
-            SettingsStore::update(cx, |store, cx| {
-                store.update_user_settings::<AllLanguageSettings>(cx, |_| {});
-            });
-        });
-    }
-
-    pub struct TestEmbeddingProvider {
-        batch_size: usize,
-        compute_embedding: Box<dyn Fn(&str) -> Result<Embedding> + Send + Sync>,
-    }
-
-    impl TestEmbeddingProvider {
-        pub fn new(
-            batch_size: usize,
-            compute_embedding: impl 'static + Fn(&str) -> Result<Embedding> + Send + Sync,
-        ) -> Self {
-            Self {
-                batch_size,
-                compute_embedding: Box::new(compute_embedding),
-            }
-        }
-    }
-
-    impl EmbeddingProvider for TestEmbeddingProvider {
-        fn embed<'a>(
-            &'a self,
-            texts: &'a [TextToEmbed<'a>],
-        ) -> BoxFuture<'a, Result<Vec<Embedding>>> {
-            let embeddings = texts
-                .iter()
-                .map(|to_embed| (self.compute_embedding)(to_embed.text))
-                .collect();
-            future::ready(embeddings).boxed()
-        }
-
-        fn batch_size(&self) -> usize {
-            self.batch_size
-        }
-    }
-
-    #[gpui::test]
-    async fn test_search(cx: &mut TestAppContext) {
-        cx.executor().allow_parking();
-
-        init_test(cx);
-
-        cx.update(|cx| {
-            // This functionality is staff-flagged.
-            cx.update_flags(true, vec![]);
-        });
-
-        let temp_dir = tempfile::tempdir().unwrap();
-
-        let mut semantic_index = SemanticDb::new(
-            temp_dir.path().into(),
-            Arc::new(TestEmbeddingProvider::new(16, |text| {
-                let mut embedding = vec![0f32; 2];
-                // if the text contains garbage, give it a 1 in the first dimension
-                if text.contains("garbage in") {
-                    embedding[0] = 0.9;
-                } else {
-                    embedding[0] = -0.9;
-                }
-
-                if text.contains("garbage out") {
-                    embedding[1] = 0.9;
-                } else {
-                    embedding[1] = -0.9;
-                }
-
-                Ok(Embedding::new(embedding))
-            })),
-            &mut cx.to_async(),
-        )
-        .await
-        .unwrap();
-
-        let fs = FakeFs::new(cx.executor());
-        let project_path = Path::new("/fake_project");
-
-        fs.insert_tree(
-            project_path,
-            json!({
-                "fixture": {
-                    "main.rs": include_str!("../fixture/main.rs"),
-                    "needle.md": include_str!("../fixture/needle.md"),
-                }
-            }),
-        )
-        .await;
-
-        let project = Project::test(fs, [project_path], cx).await;
-
-        let project_index = cx.update(|cx| {
-            let language_registry = project.read(cx).languages().clone();
-            let node_runtime = project.read(cx).node_runtime().unwrap().clone();
-            languages::init(language_registry, node_runtime, cx);
-            semantic_index.create_project_index(project.clone(), cx)
-        });
-
-        cx.run_until_parked();
-        while cx
-            .update(|cx| semantic_index.remaining_summaries(&project.downgrade(), cx))
-            .unwrap()
-            > 0
-        {
-            cx.run_until_parked();
-        }
-
-        let results = cx
-            .update(|cx| {
-                let project_index = project_index.read(cx);
-                let query = "garbage in, garbage out";
-                project_index.search(vec![query.into()], 4, cx)
-            })
-            .await
-            .unwrap();
-
-        assert!(
-            results.len() > 1,
-            "should have found some results, but only found {:?}",
-            results
-        );
-
-        for result in &results {
-            println!("result: {:?}", result.path);
-            println!("score: {:?}", result.score);
-        }
-
-        // Find result that is greater than 0.5
-        let search_result = results.iter().find(|result| result.score > 0.9).unwrap();
-
-        assert_eq!(
-            search_result.path.to_string_lossy(),
-            path!("fixture/needle.md")
-        );
-
-        let content = cx
-            .update(|cx| {
-                let worktree = search_result.worktree.read(cx);
-                let entry_abs_path = worktree.abs_path().join(&search_result.path);
-                let fs = project.read(cx).fs().clone();
-                cx.background_spawn(async move { fs.load(&entry_abs_path).await.unwrap() })
-            })
-            .await;
-
-        let range = search_result.range.clone();
-        let content = content[range].to_owned();
-
-        assert!(content.contains("garbage in, garbage out"));
-    }
-
-    #[gpui::test]
-    async fn test_embed_files(cx: &mut TestAppContext) {
-        cx.executor().allow_parking();
-
-        let provider = Arc::new(TestEmbeddingProvider::new(3, |text| {
-            anyhow::ensure!(
-                !text.contains('g'),
-                "cannot embed text containing a 'g' character"
-            );
-            Ok(Embedding::new(
-                ('a'..='z')
-                    .map(|char| text.chars().filter(|c| *c == char).count() as f32)
-                    .collect(),
-            ))
-        }));
-
-        let (indexing_progress_tx, _) = channel::unbounded();
-        let indexing_entries = Arc::new(IndexingEntrySet::new(indexing_progress_tx));
-
-        let (chunked_files_tx, chunked_files_rx) = channel::unbounded::<ChunkedFile>();
-        chunked_files_tx
-            .send_blocking(ChunkedFile {
-                path: Path::new("test1.md").into(),
-                mtime: None,
-                handle: indexing_entries.insert(ProjectEntryId::from_proto(0)),
-                text: "abcdefghijklmnop".to_string(),
-                chunks: [0..4, 4..8, 8..12, 12..16]
-                    .into_iter()
-                    .map(|range| Chunk {
-                        range,
-                        digest: Default::default(),
-                    })
-                    .collect(),
-            })
-            .unwrap();
-        chunked_files_tx
-            .send_blocking(ChunkedFile {
-                path: Path::new("test2.md").into(),
-                mtime: None,
-                handle: indexing_entries.insert(ProjectEntryId::from_proto(1)),
-                text: "qrstuvwxyz".to_string(),
-                chunks: [0..4, 4..8, 8..10]
-                    .into_iter()
-                    .map(|range| Chunk {
-                        range,
-                        digest: Default::default(),
-                    })
-                    .collect(),
-            })
-            .unwrap();
-        chunked_files_tx.close();
-
-        let embed_files_task =
-            cx.update(|cx| EmbeddingIndex::embed_files(provider.clone(), chunked_files_rx, cx));
-        embed_files_task.task.await.unwrap();
-
-        let embedded_files_rx = embed_files_task.files;
-        let mut embedded_files = Vec::new();
-        while let Ok((embedded_file, _)) = embedded_files_rx.recv().await {
-            embedded_files.push(embedded_file);
-        }
-
-        assert_eq!(embedded_files.len(), 1);
-        assert_eq!(embedded_files[0].path.as_ref(), Path::new("test2.md"));
-        assert_eq!(
-            embedded_files[0]
-                .chunks
-                .iter()
-                .map(|embedded_chunk| { embedded_chunk.embedding.clone() })
-                .collect::<Vec<Embedding>>(),
-            vec![
-                (provider.compute_embedding)("qrst").unwrap(),
-                (provider.compute_embedding)("uvwx").unwrap(),
-                (provider.compute_embedding)("yz").unwrap(),
-            ],
-        );
-    }
-
-    #[gpui::test]
-    async fn test_load_search_results(cx: &mut TestAppContext) {
-        init_test(cx);
-
-        let fs = FakeFs::new(cx.executor());
-        let project_path = Path::new("/fake_project");
-
-        let file1_content = "one\ntwo\nthree\nfour\nfive\n";
-        let file2_content = "aaa\nbbb\nccc\nddd\neee\n";
-
-        fs.insert_tree(
-            project_path,
-            json!({
-                "file1.txt": file1_content,
-                "file2.txt": file2_content,
-            }),
-        )
-        .await;
-
-        let fs = fs as Arc<dyn Fs>;
-        let project = Project::test(fs.clone(), [project_path], cx).await;
-        let worktree = project.read_with(cx, |project, cx| project.worktrees(cx).next().unwrap());
-
-        // chunk that is already newline-aligned
-        let search_results = vec![SearchResult {
-            worktree: worktree.clone(),
-            path: Path::new("file1.txt").into(),
-            range: 0..file1_content.find("four").unwrap(),
-            score: 0.5,
-            query_index: 0,
-        }];
-        assert_eq!(
-            SemanticDb::load_results(search_results, &fs, &cx.to_async())
-                .await
-                .unwrap(),
-            &[LoadedSearchResult {
-                path: Path::new("file1.txt").into(),
-                full_path: "fake_project/file1.txt".into(),
-                excerpt_content: "one\ntwo\nthree\n".into(),
-                row_range: 0..=2,
-                query_index: 0,
-            }]
-        );
-
-        // chunk that is *not* newline-aligned
-        let search_results = vec![SearchResult {
-            worktree: worktree.clone(),
-            path: Path::new("file1.txt").into(),
-            range: file1_content.find("two").unwrap() + 1..file1_content.find("four").unwrap() + 2,
-            score: 0.5,
-            query_index: 0,
-        }];
-        assert_eq!(
-            SemanticDb::load_results(search_results, &fs, &cx.to_async())
-                .await
-                .unwrap(),
-            &[LoadedSearchResult {
-                path: Path::new("file1.txt").into(),
-                full_path: "fake_project/file1.txt".into(),
-                excerpt_content: "two\nthree\nfour\n".into(),
-                row_range: 1..=3,
-                query_index: 0,
-            }]
-        );
-
-        // chunks that are adjacent
-
-        let search_results = vec![
-            SearchResult {
-                worktree: worktree.clone(),
-                path: Path::new("file1.txt").into(),
-                range: file1_content.find("two").unwrap()..file1_content.len(),
-                score: 0.6,
-                query_index: 0,
-            },
-            SearchResult {
-                worktree: worktree.clone(),
-                path: Path::new("file1.txt").into(),
-                range: 0..file1_content.find("two").unwrap(),
-                score: 0.5,
-                query_index: 1,
-            },
-            SearchResult {
-                worktree: worktree.clone(),
-                path: Path::new("file2.txt").into(),
-                range: 0..file2_content.len(),
-                score: 0.8,
-                query_index: 1,
-            },
-        ];
-        assert_eq!(
-            SemanticDb::load_results(search_results, &fs, &cx.to_async())
-                .await
-                .unwrap(),
-            &[
-                LoadedSearchResult {
-                    path: Path::new("file2.txt").into(),
-                    full_path: "fake_project/file2.txt".into(),
-                    excerpt_content: file2_content.into(),
-                    row_range: 0..=4,
-                    query_index: 1,
-                },
-                LoadedSearchResult {
-                    path: Path::new("file1.txt").into(),
-                    full_path: "fake_project/file1.txt".into(),
-                    excerpt_content: file1_content.into(),
-                    row_range: 0..=4,
-                    query_index: 0,
-                }
-            ]
-        );
-    }
-}
diff --git a/crates/semantic_index/src/summary_backlog.rs b/crates/semantic_index/src/summary_backlog.rs
deleted file mode 100644
index e77fa4862f7e0d300a3565acfbe38bda027d9cd7..0000000000000000000000000000000000000000
--- a/crates/semantic_index/src/summary_backlog.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-use collections::HashMap;
-use fs::MTime;
-use std::{path::Path, sync::Arc};
-
-const MAX_FILES_BEFORE_RESUMMARIZE: usize = 4;
-const MAX_BYTES_BEFORE_RESUMMARIZE: u64 = 1_000_000; // 1 MB
-
-#[derive(Default, Debug)]
-pub struct SummaryBacklog {
-    /// Key: path to a file that needs summarization, but that we haven't summarized yet. Value: that file's size on disk, in bytes, and its mtime.
-    files: HashMap<Arc<Path>, (u64, Option<MTime>)>,
-    /// Cache of the sum of all values in `files`, so we don't have to traverse the whole map to check if we're over the byte limit.
-    total_bytes: u64,
-}
-
-impl SummaryBacklog {
-    /// Store the given path in the backlog, along with how many bytes are in it.
-    pub fn insert(&mut self, path: Arc<Path>, bytes_on_disk: u64, mtime: Option<MTime>) {
-        let (prev_bytes, _) = self
-            .files
-            .insert(path, (bytes_on_disk, mtime))
-            .unwrap_or_default(); // Default to 0 prev_bytes
-
-        // Update the cached total by subtracting out the old amount and adding the new one.
-        self.total_bytes = self.total_bytes - prev_bytes + bytes_on_disk;
-    }
-
-    /// Returns true if the total number of bytes in the backlog exceeds a predefined threshold.
-    pub fn needs_drain(&self) -> bool {
-        self.files.len() > MAX_FILES_BEFORE_RESUMMARIZE ||
-        // The whole purpose of the cached total_bytes is to make this comparison cheap.
-        // Otherwise we'd have to traverse the entire dictionary every time we wanted this answer.
-        self.total_bytes > MAX_BYTES_BEFORE_RESUMMARIZE
-    }
-
-    /// Remove all the entries in the backlog and return the file paths as an iterator.
-    #[allow(clippy::needless_lifetimes)] // Clippy thinks this 'a can be elided, but eliding it gives a compile error
-    pub fn drain<'a>(&'a mut self) -> impl Iterator<Item = (Arc<Path>, Option<MTime>)> + 'a {
-        self.total_bytes = 0;
-
-        self.files
-            .drain()
-            .map(|(path, (_size, mtime))| (path, mtime))
-    }
-
-    pub fn len(&self) -> usize {
-        self.files.len()
-    }
-}
diff --git a/crates/semantic_index/src/summary_index.rs b/crates/semantic_index/src/summary_index.rs
deleted file mode 100644
index 9a3eb302edaaef831f515edf3492aecf59bf17f7..0000000000000000000000000000000000000000
--- a/crates/semantic_index/src/summary_index.rs
+++ /dev/null
@@ -1,696 +0,0 @@
-use anyhow::{Context as _, Result, anyhow};
-use arrayvec::ArrayString;
-use fs::{Fs, MTime};
-use futures::{TryFutureExt, stream::StreamExt};
-use futures_batch::ChunksTimeoutStreamExt;
-use gpui::{App, AppContext as _, Entity, Task};
-use heed::{
-    RoTxn,
-    types::{SerdeBincode, Str},
-};
-use language_model::{
-    LanguageModelCompletionEvent, LanguageModelId, LanguageModelRegistry, LanguageModelRequest,
-    LanguageModelRequestMessage, Role,
-};
-use log;
-use parking_lot::Mutex;
-use project::{Entry, UpdatedEntriesSet, Worktree};
-use serde::{Deserialize, Serialize};
-use smol::channel;
-use std::{
-    future::Future,
-    path::Path,
-    pin::pin,
-    sync::Arc,
-    time::{Duration, Instant},
-};
-use util::ResultExt;
-use worktree::Snapshot;
-
-use crate::{indexing::IndexingEntrySet, summary_backlog::SummaryBacklog};
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct FileSummary {
-    pub filename: String,
-    pub summary: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct UnsummarizedFile {
-    // Path to the file on disk
-    path: Arc<Path>,
-    // The mtime of the file on disk
-    mtime: Option<MTime>,
-    // BLAKE3 hash of the source file's contents
-    digest: Blake3Digest,
-    // The source file's contents
-    contents: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct SummarizedFile {
-    // Path to the file on disk
-    path: String,
-    // The mtime of the file on disk
-    mtime: Option<MTime>,
-    // BLAKE3 hash of the source file's contents
-    digest: Blake3Digest,
-    // The LLM's summary of the file's contents
-    summary: String,
-}
-
-/// This is what blake3's to_hex() method returns - see https://docs.rs/blake3/1.5.3/src/blake3/lib.rs.html#246
-pub type Blake3Digest = ArrayString<{ blake3::OUT_LEN * 2 }>;
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct FileDigest {
-    pub mtime: Option<MTime>,
-    pub digest: Blake3Digest,
-}
-
-struct NeedsSummary {
-    files: channel::Receiver<UnsummarizedFile>,
-    task: Task<Result<()>>,
-}
-
-struct SummarizeFiles {
-    files: channel::Receiver<SummarizedFile>,
-    task: Task<Result<()>>,
-}
-
-pub struct SummaryIndex {
-    worktree: Entity<Worktree>,
-    fs: Arc<dyn Fs>,
-    db_connection: heed::Env,
-    file_digest_db: heed::Database<Str, SerdeBincode<FileDigest>>, // Key: file path. Val: BLAKE3 digest of its contents.
-    summary_db: heed::Database<SerdeBincode<Blake3Digest>, Str>, // Key: BLAKE3 digest of a file's contents. Val: LLM summary of those contents.
-    backlog: Arc<Mutex<SummaryBacklog>>,
-    _entry_ids_being_indexed: Arc<IndexingEntrySet>, // TODO can this be removed?
-}
-
-struct Backlogged {
-    paths_to_digest: channel::Receiver<Vec<(Arc<Path>, Option<MTime>)>>,
-    task: Task<Result<()>>,
-}
-
-struct MightNeedSummaryFiles {
-    files: channel::Receiver<UnsummarizedFile>,
-    task: Task<Result<()>>,
-}
-
-impl SummaryIndex {
-    pub fn new(
-        worktree: Entity<Worktree>,
-        fs: Arc<dyn Fs>,
-        db_connection: heed::Env,
-        file_digest_db: heed::Database<Str, SerdeBincode<FileDigest>>,
-        summary_db: heed::Database<SerdeBincode<Blake3Digest>, Str>,
-        _entry_ids_being_indexed: Arc<IndexingEntrySet>,
-    ) -> Self {
-        Self {
-            worktree,
-            fs,
-            db_connection,
-            file_digest_db,
-            summary_db,
-            _entry_ids_being_indexed,
-            backlog: Default::default(),
-        }
-    }
-
-    pub fn file_digest_db(&self) -> heed::Database<Str, SerdeBincode<FileDigest>> {
-        self.file_digest_db
-    }
-
-    pub fn summary_db(&self) -> heed::Database<SerdeBincode<Blake3Digest>, Str> {
-        self.summary_db
-    }
-
-    pub fn index_entries_changed_on_disk(
-        &self,
-        is_auto_available: bool,
-        cx: &App,
-    ) -> impl Future<Output = Result<()>> + use<> {
-        let start = Instant::now();
-        let backlogged;
-        let digest;
-        let needs_summary;
-        let summaries;
-        let persist;
-
-        if is_auto_available {
-            let worktree = self.worktree.read(cx).snapshot();
-            let worktree_abs_path = worktree.abs_path().clone();
-
-            backlogged = self.scan_entries(worktree, cx);
-            digest = self.digest_files(backlogged.paths_to_digest, worktree_abs_path, cx);
-            needs_summary = self.check_summary_cache(digest.files, cx);
-            summaries = self.summarize_files(needs_summary.files, cx);
-            persist = self.persist_summaries(summaries.files, cx);
-        } else {
-            // This feature is only staff-shipped, so make the rest of these no-ops.
-            backlogged = Backlogged {
-                paths_to_digest: channel::unbounded().1,
-                task: Task::ready(Ok(())),
-            };
-            digest = MightNeedSummaryFiles {
-                files: channel::unbounded().1,
-                task: Task::ready(Ok(())),
-            };
-            needs_summary = NeedsSummary {
-                files: channel::unbounded().1,
-                task: Task::ready(Ok(())),
-            };
-            summaries = SummarizeFiles {
-                files: channel::unbounded().1,
-                task: Task::ready(Ok(())),
-            };
-            persist = Task::ready(Ok(()));
-        }
-
-        async move {
-            futures::try_join!(
-                backlogged.task,
-                digest.task,
-                needs_summary.task,
-                summaries.task,
-                persist
-            )?;
-
-            if is_auto_available {
-                log::info!(
-                    "Summarizing everything that changed on disk took {:?}",
-                    start.elapsed()
-                );
-            }
-
-            Ok(())
-        }
-    }
-
-    pub fn index_updated_entries(
-        &mut self,
-        updated_entries: UpdatedEntriesSet,
-        is_auto_available: bool,
-        cx: &App,
-    ) -> impl Future<Output = Result<()>> + use<> {
-        let start = Instant::now();
-        let backlogged;
-        let digest;
-        let needs_summary;
-        let summaries;
-        let persist;
-
-        if is_auto_available {
-            let worktree = self.worktree.read(cx).snapshot();
-            let worktree_abs_path = worktree.abs_path().clone();
-
-            backlogged = self.scan_updated_entries(worktree, updated_entries, cx);
-            digest = self.digest_files(backlogged.paths_to_digest, worktree_abs_path, cx);
-            needs_summary = self.check_summary_cache(digest.files, cx);
-            summaries = self.summarize_files(needs_summary.files, cx);
-            persist = self.persist_summaries(summaries.files, cx);
-        } else {
-            // This feature is only staff-shipped, so make the rest of these no-ops.
-            backlogged = Backlogged {
-                paths_to_digest: channel::unbounded().1,
-                task: Task::ready(Ok(())),
-            };
-            digest = MightNeedSummaryFiles {
-                files: channel::unbounded().1,
-                task: Task::ready(Ok(())),
-            };
-            needs_summary = NeedsSummary {
-                files: channel::unbounded().1,
-                task: Task::ready(Ok(())),
-            };
-            summaries = SummarizeFiles {
-                files: channel::unbounded().1,
-                task: Task::ready(Ok(())),
-            };
-            persist = Task::ready(Ok(()));
-        }
-
-        async move {
-            futures::try_join!(
-                backlogged.task,
-                digest.task,
-                needs_summary.task,
-                summaries.task,
-                persist
-            )?;
-
-            log::debug!("Summarizing updated entries took {:?}", start.elapsed());
-
-            Ok(())
-        }
-    }
-
-    fn check_summary_cache(
-        &self,
-        might_need_summary: channel::Receiver<UnsummarizedFile>,
-        cx: &App,
-    ) -> NeedsSummary {
-        let db_connection = self.db_connection.clone();
-        let db = self.summary_db;
-        let (needs_summary_tx, needs_summary_rx) = channel::bounded(512);
-        let task = cx.background_spawn(async move {
-            let mut might_need_summary = pin!(might_need_summary);
-            while let Some(file) = might_need_summary.next().await {
-                let tx = db_connection
-                    .read_txn()
-                    .context("Failed to create read transaction for checking which hashes are in summary cache")?;
-
-                match db.get(&tx, &file.digest) {
-                    Ok(opt_answer) => {
-                        if opt_answer.is_none() {
-                            // It's not in the summary cache db, so we need to summarize it.
-                            log::debug!("File {:?} (digest {:?}) was NOT in the db cache and needs to be resummarized.", file.path.display(), &file.digest);
-                            needs_summary_tx.send(file).await?;
-                        } else {
-                            log::debug!("File {:?} (digest {:?}) was in the db cache and does not need to be resummarized.", file.path.display(), &file.digest);
-                        }
-                    }
-                    Err(err) => {
-                        log::error!("Reading from the summaries database failed: {:?}", err);
-                    }
-                }
-            }
-
-            Ok(())
-        });
-
-        NeedsSummary {
-            files: needs_summary_rx,
-            task,
-        }
-    }
-
-    fn scan_entries(&self, worktree: Snapshot, cx: &App) -> Backlogged {
-        let (tx, rx) = channel::bounded(512);
-        let db_connection = self.db_connection.clone();
-        let digest_db = self.file_digest_db;
-        let backlog = Arc::clone(&self.backlog);
-        let task = cx.background_spawn(async move {
-            let txn = db_connection
-                .read_txn()
-                .context("failed to create read transaction")?;
-
-            for entry in worktree.files(false, 0) {
-                let needs_summary =
-                    Self::add_to_backlog(Arc::clone(&backlog), digest_db, &txn, entry);
-
-                if !needs_summary.is_empty() {
-                    tx.send(needs_summary).await?;
-                }
-            }
-
-            // TODO delete db entries for deleted files
-
-            Ok(())
-        });
-
-        Backlogged {
-            paths_to_digest: rx,
-            task,
-        }
-    }
-
-    fn add_to_backlog(
-        backlog: Arc<Mutex<SummaryBacklog>>,
-        digest_db: heed::Database<Str, SerdeBincode<FileDigest>>,
-        txn: &RoTxn<'_>,
-        entry: &Entry,
-    ) -> Vec<(Arc<Path>, Option<MTime>)> {
-        let entry_db_key = db_key_for_path(&entry.path);
-
-        match digest_db.get(txn, &entry_db_key) {
-            Ok(opt_saved_digest) => {
-                // The file path is the same, but the mtime is different. (Or there was no mtime.)
-                // It needs updating, so add it to the backlog! Then, if the backlog is full, drain it and summarize its contents.
-                if entry.mtime != opt_saved_digest.and_then(|digest| digest.mtime) {
-                    let mut backlog = backlog.lock();
-
-                    log::info!(
-                        "Inserting {:?} ({:?} bytes) into backlog",
-                        &entry.path,
-                        entry.size,
-                    );
-                    backlog.insert(Arc::clone(&entry.path), entry.size, entry.mtime);
-
-                    if backlog.needs_drain() {
-                        log::info!("Draining summary backlog...");
-                        return backlog.drain().collect();
-                    }
-                }
-            }
-            Err(err) => {
-                log::error!(
-                    "Error trying to get file digest db entry {:?}: {:?}",
-                    &entry_db_key,
-                    err
-                );
-            }
-        }
-
-        Vec::new()
-    }
-
-    fn scan_updated_entries(
-        &self,
-        worktree: Snapshot,
-        updated_entries: UpdatedEntriesSet,
-        cx: &App,
-    ) -> Backlogged {
-        log::info!("Scanning for updated entries that might need summarization...");
-        let (tx, rx) = channel::bounded(512);
-        // let (deleted_entry_ranges_tx, deleted_entry_ranges_rx) = channel::bounded(128);
-        let db_connection = self.db_connection.clone();
-        let digest_db = self.file_digest_db;
-        let backlog = Arc::clone(&self.backlog);
-        let task = cx.background_spawn(async move {
-            let txn = db_connection
-                .read_txn()
-                .context("failed to create read transaction")?;
-
-            for (path, entry_id, status) in updated_entries.iter() {
-                match status {
-                    project::PathChange::Loaded
-                    | project::PathChange::Added
-                    | project::PathChange::Updated
-                    | project::PathChange::AddedOrUpdated => {
-                        if let Some(entry) = worktree.entry_for_id(*entry_id)
-                            && entry.is_file()
-                        {
-                            let needs_summary =
-                                Self::add_to_backlog(Arc::clone(&backlog), digest_db, &txn, entry);
-
-                            if !needs_summary.is_empty() {
-                                tx.send(needs_summary).await?;
-                            }
-                        }
-                    }
-                    project::PathChange::Removed => {
-                        let _db_path = db_key_for_path(path);
-                        // TODO delete db entries for deleted files
-                        // deleted_entry_ranges_tx
-                        //     .send((Bound::Included(db_path.clone()), Bound::Included(db_path)))
-                        //     .await?;
-                    }
-                }
-            }
-
-            Ok(())
-        });
-
-        Backlogged {
-            paths_to_digest: rx,
-            // deleted_entry_ranges: deleted_entry_ranges_rx,
-            task,
-        }
-    }
-
-    fn digest_files(
-        &self,
-        paths: channel::Receiver<Vec<(Arc<Path>, Option<MTime>)>>,
-        worktree_abs_path: Arc<Path>,
-        cx: &App,
-    ) -> MightNeedSummaryFiles {
-        let fs = self.fs.clone();
-        let (rx, tx) = channel::bounded(2048);
-        let task = cx.spawn(async move |cx| {
-            cx.background_executor()
-                .scoped(|cx| {
-                    for _ in 0..cx.num_cpus() {
-                        cx.spawn(async {
-                            while let Ok(pairs) = paths.recv().await {
-                                // Note: we could process all these files concurrently if desired. Might or might not speed things up.
-                                for (path, mtime) in pairs {
-                                    let entry_abs_path = worktree_abs_path.join(&path);
-
-                                    // Load the file's contents and compute its hash digest.
-                                    let unsummarized_file = {
-                                        let Some(contents) = fs
-                                            .load(&entry_abs_path)
-                                            .await
-                                            .with_context(|| {
-                                                format!("failed to read path {entry_abs_path:?}")
-                                            })
-                                            .log_err()
-                                        else {
-                                            continue;
-                                        };
-
-                                        let digest = {
-                                            let mut hasher = blake3::Hasher::new();
-                                            // Incorporate both the (relative) file path as well as the contents of the file into the hash.
-                                            // This is because in some languages and frameworks, identical files can do different things
-                                            // depending on their paths (e.g. Rails controllers). It's also why we send the path to the model.
-                                            hasher.update(path.display().to_string().as_bytes());
-                                            hasher.update(contents.as_bytes());
-                                            hasher.finalize().to_hex()
-                                        };
-
-                                        UnsummarizedFile {
-                                            digest,
-                                            contents,
-                                            path,
-                                            mtime,
-                                        }
-                                    };
-
-                                    if let Err(err) = rx
-                                        .send(unsummarized_file)
-                                        .map_err(|error| anyhow!(error))
-                                        .await
-                                    {
-                                        log::error!("Error: {:?}", err);
-
-                                        return;
-                                    }
-                                }
-                            }
-                        });
-                    }
-                })
-                .await;
-            Ok(())
-        });
-
-        MightNeedSummaryFiles { files: tx, task }
-    }
-
-    fn summarize_files(
-        &self,
-        unsummarized_files: channel::Receiver<UnsummarizedFile>,
-        cx: &App,
-    ) -> SummarizeFiles {
-        let (summarized_tx, summarized_rx) = channel::bounded(512);
-        let task = cx.spawn(async move |cx| {
-            while let Ok(file) = unsummarized_files.recv().await {
-                log::debug!("Summarizing {:?}", file);
-                let summary = cx
-                    .update(|cx| Self::summarize_code(&file.contents, &file.path, cx))?
-                    .await
-                    .unwrap_or_else(|err| {
-                        // Log a warning because we'll continue anyway.
-                        // In the future, we may want to try splitting it up into multiple requests and concatenating the summaries,
-                        // but this might give bad summaries due to cutting off source code files in the middle.
-                        log::warn!("Failed to summarize {} - {:?}", file.path.display(), err);
-
-                        String::new()
-                    });
-
-                // Note that the summary could be empty because of an error talking to a cloud provider,
-                // e.g. because the context limit was exceeded. In that case, we return Ok(String::new()).
-                if !summary.is_empty() {
-                    summarized_tx
-                        .send(SummarizedFile {
-                            path: file.path.display().to_string(),
-                            digest: file.digest,
-                            summary,
-                            mtime: file.mtime,
-                        })
-                        .await?
-                }
-            }
-
-            Ok(())
-        });
-
-        SummarizeFiles {
-            files: summarized_rx,
-            task,
-        }
-    }
-
-    fn summarize_code(
-        code: &str,
-        path: &Path,
-        cx: &App,
-    ) -> impl Future<Output = Result<String>> + use<> {
-        let start = Instant::now();
-        let (summary_model_id, use_cache): (LanguageModelId, bool) = (
-            "Qwen/Qwen2-7B-Instruct".to_string().into(), // TODO read this from the user's settings.
-            false, // qwen2 doesn't have a cache, but we should probably infer this from the model
-        );
-        let Some(model) = LanguageModelRegistry::read_global(cx)
-            .available_models(cx)
-            .find(|model| &model.id() == &summary_model_id)
-        else {
-            return cx.background_spawn(async move {
-                anyhow::bail!("Couldn't find the preferred summarization model ({summary_model_id:?}) in the language registry's available models")
-            });
-        };
-        let utf8_path = path.to_string_lossy();
-        const PROMPT_BEFORE_CODE: &str = "Summarize what the code in this file does in 3 sentences, using no newlines or bullet points in the summary:";
-        let prompt = format!("{PROMPT_BEFORE_CODE}\n{utf8_path}:\n{code}");
-
-        log::debug!(
-            "Summarizing code by sending this prompt to {:?}: {:?}",
-            model.name(),
-            &prompt
-        );
-
-        let request = LanguageModelRequest {
-            thread_id: None,
-            prompt_id: None,
-            mode: None,
-            intent: None,
-            messages: vec![LanguageModelRequestMessage {
-                role: Role::User,
-                content: vec![prompt.into()],
-                cache: use_cache,
-            }],
-            tools: Vec::new(),
-            tool_choice: None,
-            stop: Vec::new(),
-            temperature: None,
-            thinking_allowed: true,
-        };
-
-        let code_len = code.len();
-        cx.spawn(async move |cx| {
-            let stream = model.stream_completion(request, cx);
-            cx.background_spawn(async move {
-                let answer: String = stream
-                    .await?
-                    .filter_map(|event| async {
-                        if let Ok(LanguageModelCompletionEvent::Text(text)) = event {
-                            Some(text)
-                        } else {
-                            None
-                        }
-                    })
-                    .collect()
-                    .await;
-
-                log::info!(
-                    "It took {:?} to summarize {:?} bytes of code.",
-                    start.elapsed(),
-                    code_len
-                );
-
-                log::debug!("Summary was: {:?}", &answer);
-
-                Ok(answer)
-            })
-            .await
-
-            // TODO if summarization failed, put it back in the backlog!
-        })
-    }
-
-    fn persist_summaries(
-        &self,
-        summaries: channel::Receiver<SummarizedFile>,
-        cx: &App,
-    ) -> Task<Result<()>> {
-        let db_connection = self.db_connection.clone();
-        let digest_db = self.file_digest_db;
-        let summary_db = self.summary_db;
-        cx.background_spawn(async move {
-            let mut summaries = pin!(summaries.chunks_timeout(4096, Duration::from_secs(2)));
-            while let Some(summaries) = summaries.next().await {
-                let mut txn = db_connection.write_txn()?;
-                for file in &summaries {
-                    log::debug!(
-                        "Saving summary of {:?} - which is {} bytes of summary for content digest {:?}",
-                        &file.path,
-                        file.summary.len(),
-                        file.digest
-                    );
-                    digest_db.put(
-                        &mut txn,
-                        &file.path,
-                        &FileDigest {
-                            mtime: file.mtime,
-                            digest: file.digest,
-                        },
-                    )?;
-                    summary_db.put(&mut txn, &file.digest, &file.summary)?;
-                }
-                txn.commit()?;
-
-                drop(summaries);
-                log::debug!("committed summaries");
-            }
-
-            Ok(())
-        })
-    }
-
-    /// Empty out the backlog of files that haven't been resummarized, and resummarize them immediately.
-    pub(crate) fn flush_backlog(
-        &self,
-        worktree_abs_path: Arc<Path>,
-        cx: &App,
-    ) -> impl Future<Output = Result<()>> + use<> {
-        let start = Instant::now();
-        let backlogged = {
-            let (tx, rx) = channel::bounded(512);
-            let needs_summary: Vec<(Arc<Path>, Option<MTime>)> = {
-                let mut backlog = self.backlog.lock();
-
-                backlog.drain().collect()
-            };
-
-            let task = cx.background_spawn(async move {
-                tx.send(needs_summary).await?;
-                Ok(())
-            });
-
-            Backlogged {
-                paths_to_digest: rx,
-                task,
-            }
-        };
-
-        let digest = self.digest_files(backlogged.paths_to_digest, worktree_abs_path, cx);
-        let needs_summary = self.check_summary_cache(digest.files, cx);
-        let summaries = self.summarize_files(needs_summary.files, cx);
-        let persist = self.persist_summaries(summaries.files, cx);
-
-        async move {
-            futures::try_join!(
-                backlogged.task,
-                digest.task,
-                needs_summary.task,
-                summaries.task,
-                persist
-            )?;
-
-            log::info!("Summarizing backlogged entries took {:?}", start.elapsed());
-
-            Ok(())
-        }
-    }
-
-    pub(crate) fn backlog_len(&self) -> usize {
-        self.backlog.lock().len()
-    }
-}
-
-fn db_key_for_path(path: &Arc<Path>) -> String {
-    path.to_string_lossy().replace('/', "\0")
-}
diff --git a/crates/semantic_index/src/worktree_index.rs b/crates/semantic_index/src/worktree_index.rs
deleted file mode 100644
index 84b932d2965562e2c7deb02019449ad69ade7bc0..0000000000000000000000000000000000000000
--- a/crates/semantic_index/src/worktree_index.rs
+++ /dev/null
@@ -1,205 +0,0 @@
-use crate::embedding::EmbeddingProvider;
-use crate::embedding_index::EmbeddingIndex;
-use crate::indexing::IndexingEntrySet;
-use crate::summary_index::SummaryIndex;
-use anyhow::Result;
-use fs::Fs;
-use futures::future::Shared;
-use gpui::{App, AppContext as _, AsyncApp, Context, Entity, Subscription, Task, WeakEntity};
-use language::LanguageRegistry;
-use log;
-use project::{UpdatedEntriesSet, Worktree};
-use smol::channel;
-use std::sync::Arc;
-use util::ResultExt;
-
-#[derive(Clone)]
-pub enum WorktreeIndexHandle {
-    Loading {
-        index: Shared<Task<Result<Entity<WorktreeIndex>, Arc<anyhow::Error>>>>,
-    },
-    Loaded {
-        index: Entity<WorktreeIndex>,
-    },
-}
-
-pub struct WorktreeIndex {
-    worktree: Entity<Worktree>,
-    db_connection: heed::Env,
-    embedding_index: EmbeddingIndex,
-    summary_index: SummaryIndex,
-    entry_ids_being_indexed: Arc<IndexingEntrySet>,
-    _index_entries: Task<Result<()>>,
-    _subscription: Subscription,
-}
-
-impl WorktreeIndex {
-    pub fn load(
-        worktree: Entity<Worktree>,
-        db_connection: heed::Env,
-        language_registry: Arc<LanguageRegistry>,
-        fs: Arc<dyn Fs>,
-        status_tx: channel::Sender<()>,
-        embedding_provider: Arc<dyn EmbeddingProvider>,
-        cx: &mut App,
-    ) -> Task<Result<Entity<Self>>> {
-        let worktree_for_index = worktree.clone();
-        let worktree_for_summary = worktree.clone();
-        let worktree_abs_path = worktree.read(cx).abs_path();
-        let embedding_fs = Arc::clone(&fs);
-        let summary_fs = fs;
-        cx.spawn(async move |cx| {
-            let entries_being_indexed = Arc::new(IndexingEntrySet::new(status_tx));
-            let (embedding_index, summary_index) = cx
-                .background_spawn({
-                    let entries_being_indexed = Arc::clone(&entries_being_indexed);
-                    let db_connection = db_connection.clone();
-                    async move {
-                        let mut txn = db_connection.write_txn()?;
-                        let embedding_index = {
-                            let db_name = worktree_abs_path.to_string_lossy();
-                            let db = db_connection.create_database(&mut txn, Some(&db_name))?;
-
-                            EmbeddingIndex::new(
-                                worktree_for_index,
-                                embedding_fs,
-                                db_connection.clone(),
-                                db,
-                                language_registry,
-                                embedding_provider,
-                                Arc::clone(&entries_being_indexed),
-                            )
-                        };
-                        let summary_index = {
-                            let file_digest_db = {
-                                let db_name =
-                                // Prepend something that wouldn't be found at the beginning of an
-                                // absolute path, so we don't get db key namespace conflicts with
-                                // embeddings, which use the abs path as a key.
-                                format!("digests-{}", worktree_abs_path.to_string_lossy());
-                                db_connection.create_database(&mut txn, Some(&db_name))?
-                            };
-                            let summary_db = {
-                                let db_name =
-                                // Prepend something that wouldn't be found at the beginning of an
-                                // absolute path, so we don't get db key namespace conflicts with
-                                // embeddings, which use the abs path as a key.
-                                format!("summaries-{}", worktree_abs_path.to_string_lossy());
-                                db_connection.create_database(&mut txn, Some(&db_name))?
-                            };
-                            SummaryIndex::new(
-                                worktree_for_summary,
-                                summary_fs,
-                                db_connection.clone(),
-                                file_digest_db,
-                                summary_db,
-                                Arc::clone(&entries_being_indexed),
-                            )
-                        };
-                        txn.commit()?;
-                        anyhow::Ok((embedding_index, summary_index))
-                    }
-                })
-                .await?;
-
-            cx.new(|cx| {
-                Self::new(
-                    worktree,
-                    db_connection,
-                    embedding_index,
-                    summary_index,
-                    entries_being_indexed,
-                    cx,
-                )
-            })
-        })
-    }
-
-    pub fn new(
-        worktree: Entity<Worktree>,
-        db_connection: heed::Env,
-        embedding_index: EmbeddingIndex,
-        summary_index: SummaryIndex,
-        entry_ids_being_indexed: Arc<IndexingEntrySet>,
-        cx: &mut Context<Self>,
-    ) -> Self {
-        let (updated_entries_tx, updated_entries_rx) = channel::unbounded();
-        let _subscription = cx.subscribe(&worktree, move |_this, _worktree, event, _cx| {
-            if let worktree::Event::UpdatedEntries(update) = event {
-                log::debug!("Updating entries...");
-                _ = updated_entries_tx.try_send(update.clone());
-            }
-        });
-
-        Self {
-            db_connection,
-            embedding_index,
-            summary_index,
-            worktree,
-            entry_ids_being_indexed,
-            _index_entries: cx.spawn(async move |this, cx| {
-                Self::index_entries(this, updated_entries_rx, cx).await
-            }),
-            _subscription,
-        }
-    }
-
-    pub fn entry_ids_being_indexed(&self) -> &IndexingEntrySet {
-        self.entry_ids_being_indexed.as_ref()
-    }
-
-    pub fn worktree(&self) -> &Entity<Worktree> {
-        &self.worktree
-    }
-
-    pub fn db_connection(&self) -> &heed::Env {
-        &self.db_connection
-    }
-
-    pub fn embedding_index(&self) -> &EmbeddingIndex {
-        &self.embedding_index
-    }
-
-    pub fn summary_index(&self) -> &SummaryIndex {
-        &self.summary_index
-    }
-
-    async fn index_entries(
-        this: WeakEntity<Self>,
-        updated_entries: channel::Receiver<UpdatedEntriesSet>,
-        cx: &mut AsyncApp,
-    ) -> Result<()> {
-        let index = this.update(cx, |this, cx| {
-            futures::future::try_join(
-                this.embedding_index.index_entries_changed_on_disk(cx),
-                this.summary_index.index_entries_changed_on_disk(false, cx),
-            )
-        })?;
-        index.await.log_err();
-
-        while let Ok(updated_entries) = updated_entries.recv().await {
-            let index = this.update(cx, |this, cx| {
-                futures::future::try_join(
-                    this.embedding_index
-                        .index_updated_entries(updated_entries.clone(), cx),
-                    this.summary_index
-                        .index_updated_entries(updated_entries, false, cx),
-                )
-            })?;
-            index.await.log_err();
-        }
-
-        Ok(())
-    }
-
-    #[cfg(test)]
-    pub fn path_count(&self) -> Result<u64> {
-        use anyhow::Context as _;
-
-        let txn = self
-            .db_connection
-            .read_txn()
-            .context("failed to create read transaction")?;
-        Ok(self.embedding_index().db().len(&txn)?)
-    }
-}
diff --git a/crates/settings/src/base_keymap_setting.rs b/crates/settings/src/base_keymap_setting.rs
index fb5b445b49a1fdbfac34ce8bc1a3d17d8241e009..a6bfeecbc3c01eb5309221443d1b9905b99dcd5b 100644
--- a/crates/settings/src/base_keymap_setting.rs
+++ b/crates/settings/src/base_keymap_setting.rs
@@ -1,10 +1,10 @@
 use std::fmt::{Display, Formatter};
 
-use crate as settings;
+use crate::{self as settings};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources, VsCodeSettings};
-use settings_ui_macros::SettingsUi;
+use settings_ui_macros::{SettingsKey, SettingsUi};
 
 /// Base key bindings scheme. Base keymaps can be overridden with user keymaps.
 ///
@@ -101,16 +101,25 @@ impl BaseKeymap {
 }
 
 #[derive(
-    Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq, Default, SettingsUi,
+    Copy,
+    Clone,
+    Debug,
+    Serialize,
+    Deserialize,
+    JsonSchema,
+    PartialEq,
+    Eq,
+    Default,
+    SettingsUi,
+    SettingsKey,
 )]
 // extracted so that it can be an option, and still work with derive(SettingsUi)
+#[settings_key(None)]
 pub struct BaseKeymapSetting {
     pub base_keymap: Option<BaseKeymap>,
 }
 
 impl Settings for BaseKeymap {
-    const KEY: Option<&'static str> = None;
-
     type FileContent = BaseKeymapSetting;
 
     fn load(
diff --git a/crates/settings/src/keymap_file.rs b/crates/settings/src/keymap_file.rs
index 91fcca8d5cbddf9dd30b867b3b89848cbc86de1e..5dddff28d8d25652d366565801b249facd584344 100644
--- a/crates/settings/src/keymap_file.rs
+++ b/crates/settings/src/keymap_file.rs
@@ -1100,6 +1100,24 @@ mod tests {
             .unindent(),
         );
 
+        check_keymap_update(
+            "[]",
+            KeybindUpdateOperation::add(KeybindUpdateTarget {
+                keystrokes: &parse_keystrokes("\\ a"),
+                action_name: "zed::SomeAction",
+                context: None,
+                action_arguments: None,
+            }),
+            r#"[
+                {
+                    "bindings": {
+                        "\\ a": "zed::SomeAction"
+                    }
+                }
+            ]"#
+            .unindent(),
+        );
+
         check_keymap_update(
             "[]",
             KeybindUpdateOperation::add(KeybindUpdateTarget {
@@ -1302,6 +1320,79 @@ mod tests {
             .unindent(),
         );
 
+        check_keymap_update(
+            r#"[
+                {
+                    "bindings": {
+                        "\\ a": "zed::SomeAction"
+                    }
+                }
+            ]"#
+            .unindent(),
+            KeybindUpdateOperation::Replace {
+                target: KeybindUpdateTarget {
+                    keystrokes: &parse_keystrokes("\\ a"),
+                    action_name: "zed::SomeAction",
+                    context: None,
+                    action_arguments: None,
+                },
+                source: KeybindUpdateTarget {
+                    keystrokes: &parse_keystrokes("\\ b"),
+                    action_name: "zed::SomeOtherAction",
+                    context: None,
+                    action_arguments: Some(r#"{"foo": "bar"}"#),
+                },
+                target_keybind_source: KeybindSource::User,
+            },
+            r#"[
+                {
+                    "bindings": {
+                        "\\ b": [
+                            "zed::SomeOtherAction",
+                            {
+                                "foo": "bar"
+                            }
+                        ]
+                    }
+                }
+            ]"#
+            .unindent(),
+        );
+
+        check_keymap_update(
+            r#"[
+                {
+                    "bindings": {
+                        "\\ a": "zed::SomeAction"
+                    }
+                }
+            ]"#
+            .unindent(),
+            KeybindUpdateOperation::Replace {
+                target: KeybindUpdateTarget {
+                    keystrokes: &parse_keystrokes("\\ a"),
+                    action_name: "zed::SomeAction",
+                    context: None,
+                    action_arguments: None,
+                },
+                source: KeybindUpdateTarget {
+                    keystrokes: &parse_keystrokes("\\ a"),
+                    action_name: "zed::SomeAction",
+                    context: None,
+                    action_arguments: None,
+                },
+                target_keybind_source: KeybindSource::User,
+            },
+            r#"[
+                {
+                    "bindings": {
+                        "\\ a": "zed::SomeAction"
+                    }
+                }
+            ]"#
+            .unindent(),
+        );
+
         check_keymap_update(
             r#"[
                 {
@@ -1494,6 +1585,37 @@ mod tests {
             .unindent(),
         );
 
+        check_keymap_update(
+            r#"[
+                {
+                    "context": "SomeContext",
+                    "bindings": {
+                        "\\ a": "foo::bar",
+                        "c": "foo::baz",
+                    }
+                },
+            ]"#
+            .unindent(),
+            KeybindUpdateOperation::Remove {
+                target: KeybindUpdateTarget {
+                    context: Some("SomeContext"),
+                    keystrokes: &parse_keystrokes("\\ a"),
+                    action_name: "foo::bar",
+                    action_arguments: None,
+                },
+                target_keybind_source: KeybindSource::User,
+            },
+            r#"[
+                {
+                    "context": "SomeContext",
+                    "bindings": {
+                        "c": "foo::baz",
+                    }
+                },
+            ]"#
+            .unindent(),
+        );
+
         check_keymap_update(
             r#"[
                 {
diff --git a/crates/settings/src/settings.rs b/crates/settings/src/settings.rs
index 7e567cc085101713b0f6b100d0b47f6bf4c3531f..8a50b1afe5d0c68365efe0652421937f6dad2783 100644
--- a/crates/settings/src/settings.rs
+++ b/crates/settings/src/settings.rs
@@ -21,12 +21,12 @@ pub use keymap_file::{
 pub use settings_file::*;
 pub use settings_json::*;
 pub use settings_store::{
-    InvalidSettingsError, LocalSettingsKind, Settings, SettingsLocation, SettingsSources,
-    SettingsStore,
+    InvalidSettingsError, LocalSettingsKind, Settings, SettingsKey, SettingsLocation,
+    SettingsSources, SettingsStore,
 };
 pub use settings_ui_core::*;
 // Re-export the derive macro
-pub use settings_ui_macros::SettingsUi;
+pub use settings_ui_macros::{SettingsKey, SettingsUi};
 pub use vscode_import::{VsCodeSettings, VsCodeSettingsSource};
 
 #[derive(Clone, Debug, PartialEq)]
diff --git a/crates/settings/src/settings_json.rs b/crates/settings/src/settings_json.rs
index 480fe057eacb8d96255a3bf2d7b5f96208f87ced..70c76e23c402b8debcb5e406cc86fa7125e78c5a 100644
--- a/crates/settings/src/settings_json.rs
+++ b/crates/settings/src/settings_json.rs
@@ -140,8 +140,10 @@ pub fn replace_value_in_json_text<T: AsRef<str>>(
 
         let found_key = text
             .get(key_range.clone())
-            .map(|key_text| {
-                depth < key_path.len() && key_text == format!("\"{}\"", key_path[depth].as_ref())
+            .and_then(|key_text| {
+                serde_json::to_string(key_path[depth].as_ref())
+                    .ok()
+                    .map(|key_path| depth < key_path.len() && key_text == key_path)
             })
             .unwrap_or(false);
 
@@ -163,8 +165,8 @@ pub fn replace_value_in_json_text<T: AsRef<str>>(
     if depth == key_path.len() {
         if let Some(new_value) = new_value {
             let new_val = to_pretty_json(new_value, tab_size, tab_size * depth);
-            if let Some(replace_key) = replace_key {
-                let new_key = format!("\"{}\": ", replace_key);
+            if let Some(replace_key) = replace_key.and_then(|str| serde_json::to_string(str).ok()) {
+                let new_key = format!("{}: ", replace_key);
                 if let Some(key_start) = text[..existing_value_range.start].rfind('"') {
                     if let Some(prev_key_start) = text[..key_start].rfind('"') {
                         existing_value_range.start = prev_key_start;
diff --git a/crates/settings/src/settings_store.rs b/crates/settings/src/settings_store.rs
index 60eb132ad8b4f6419f463f32b1874ea97be07ec1..f2270711938c9bcbf27cdcb3d9271d5d2baeec27 100644
--- a/crates/settings/src/settings_store.rs
+++ b/crates/settings/src/settings_store.rs
@@ -36,17 +36,19 @@ use crate::{
     settings_ui_core::SettingsUi, update_value_in_json_text,
 };
 
-/// A value that can be defined as a user setting.
-///
-/// Settings can be loaded from a combination of multiple JSON files.
-pub trait Settings: 'static + Send + Sync {
+pub trait SettingsKey: 'static + Send + Sync {
     /// The name of a key within the JSON file from which this setting should
     /// be deserialized. If this is `None`, then the setting will be deserialized
     /// from the root object.
     const KEY: Option<&'static str>;
 
     const FALLBACK_KEY: Option<&'static str> = None;
+}
 
+/// A value that can be defined as a user setting.
+///
+/// Settings can be loaded from a combination of multiple JSON files.
+pub trait Settings: 'static + Send + Sync {
     /// The name of the keys in the [`FileContent`](Self::FileContent) that should
     /// always be written to a settings file, even if their value matches the default
     /// value.
@@ -57,8 +59,19 @@ pub trait Settings: 'static + Send + Sync {
     const PRESERVED_KEYS: Option<&'static [&'static str]> = None;
 
     /// The type that is stored in an individual JSON file.
-    type FileContent: Clone + Default + Serialize + DeserializeOwned + JsonSchema + SettingsUi;
-
+    type FileContent: Clone
+        + Default
+        + Serialize
+        + DeserializeOwned
+        + JsonSchema
+        + SettingsUi
+        + SettingsKey;
+
+    /*
+     *  let path = Settings
+     *
+     *
+     */
     /// The logic for combining together values from one or more JSON files into the
     /// final value for this setting.
     ///
@@ -71,7 +84,7 @@ pub trait Settings: 'static + Send + Sync {
         Self: Sized;
 
     fn missing_default() -> anyhow::Error {
-        anyhow::anyhow!("missing default")
+        anyhow::anyhow!("missing default for: {}", std::any::type_name::<Self>())
     }
 
     /// Use [the helpers in the vscode_import module](crate::vscode_import) to apply known
@@ -467,6 +480,13 @@ impl SettingsStore {
         &self.raw_user_settings
     }
 
+    /// Replaces current settings with the values from the given JSON.
+    pub fn set_raw_user_settings(&mut self, new_settings: Value, cx: &mut App) -> Result<()> {
+        self.raw_user_settings = new_settings;
+        self.recompute_values(None, cx)?;
+        Ok(())
+    }
+
     /// Get the configured settings profile names.
     pub fn configured_settings_profiles(&self) -> impl Iterator<Item = &str> {
         self.raw_user_settings
@@ -525,20 +545,6 @@ impl SettingsStore {
         }
     }
 
-    pub async fn load_global_settings(fs: &Arc<dyn Fs>) -> Result<String> {
-        match fs.load(paths::global_settings_file()).await {
-            result @ Ok(_) => result,
-            Err(err) => {
-                if let Some(e) = err.downcast_ref::<std::io::Error>()
-                    && e.kind() == std::io::ErrorKind::NotFound
-                {
-                    return Ok("{}".to_string());
-                }
-                Err(err)
-            }
-        }
-    }
-
     fn update_settings_file_inner(
         &self,
         fs: Arc<dyn Fs>,
@@ -595,12 +601,12 @@ impl SettingsStore {
     pub fn update_settings_file_at_path(
         &self,
         fs: Arc<dyn Fs>,
-        path: &[&str],
+        path: &[impl AsRef<str>],
         new_value: serde_json::Value,
     ) -> oneshot::Receiver<Result<()>> {
         let key_path = path
             .into_iter()
-            .cloned()
+            .map(AsRef::as_ref)
             .map(SharedString::new)
             .collect::<Vec<_>>();
         let update = move |mut old_text: String, cx: AsyncApp| {
@@ -1400,7 +1406,7 @@ impl Debug for SettingsStore {
 
 impl<T: Settings> AnySettingValue for SettingValue<T> {
     fn key(&self) -> Option<&'static str> {
-        T::KEY
+        T::FileContent::KEY
     }
 
     fn setting_type_name(&self) -> &'static str {
@@ -1452,16 +1458,21 @@ impl<T: Settings> AnySettingValue for SettingValue<T> {
         mut json: &Value,
     ) -> (Option<&'static str>, Result<DeserializedSetting>) {
         let mut key = None;
-        if let Some(k) = T::KEY {
+        if let Some(k) = T::FileContent::KEY {
             if let Some(value) = json.get(k) {
                 json = value;
                 key = Some(k);
-            } else if let Some((k, value)) = T::FALLBACK_KEY.and_then(|k| Some((k, json.get(k)?))) {
+            } else if let Some((k, value)) =
+                T::FileContent::FALLBACK_KEY.and_then(|k| Some((k, json.get(k)?)))
+            {
                 json = value;
                 key = Some(k);
             } else {
                 let value = T::FileContent::default();
-                return (T::KEY, Ok(DeserializedSetting(Box::new(value))));
+                return (
+                    T::FileContent::KEY,
+                    Ok(DeserializedSetting(Box::new(value))),
+                );
             }
         }
         let value = serde_path_to_error::deserialize::<_, T::FileContent>(json)
@@ -1505,6 +1516,7 @@ impl<T: Settings> AnySettingValue for SettingValue<T> {
                 }
             }
         }
+
         self.global_value
             .as_ref()
             .unwrap_or_else(|| panic!("no default value for setting {}", self.setting_type_name()))
@@ -1577,7 +1589,7 @@ mod tests {
     // This is so the SettingsUi macro can still work properly
     use crate as settings;
     use serde_derive::Deserialize;
-    use settings_ui_macros::SettingsUi;
+    use settings_ui_macros::{SettingsKey, SettingsUi};
     use unindent::Unindent;
 
     #[gpui::test]
@@ -2127,7 +2139,8 @@ mod tests {
         staff: bool,
     }
 
-    #[derive(Default, Clone, Serialize, Deserialize, JsonSchema, SettingsUi)]
+    #[derive(Default, Clone, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey)]
+    #[settings_key(key = "user")]
     struct UserSettingsContent {
         name: Option<String>,
         age: Option<u32>,
@@ -2135,7 +2148,6 @@ mod tests {
     }
 
     impl Settings for UserSettings {
-        const KEY: Option<&'static str> = Some("user");
         type FileContent = UserSettingsContent;
 
         fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
@@ -2150,12 +2162,37 @@ mod tests {
     #[derive(Debug, Deserialize, PartialEq)]
     struct TurboSetting(bool);
 
+    #[derive(
+        Copy,
+        Clone,
+        PartialEq,
+        Eq,
+        Debug,
+        Default,
+        serde::Serialize,
+        serde::Deserialize,
+        SettingsUi,
+        SettingsKey,
+        JsonSchema,
+    )]
+    #[serde(default)]
+    #[settings_key(None)]
+    pub struct TurboSettingContent {
+        turbo: Option<bool>,
+    }
+
     impl Settings for TurboSetting {
-        const KEY: Option<&'static str> = Some("turbo");
-        type FileContent = bool;
+        type FileContent = TurboSettingContent;
 
         fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
-            sources.json_merge()
+            Ok(Self(
+                sources
+                    .user
+                    .or(sources.server)
+                    .unwrap_or(sources.default)
+                    .turbo
+                    .unwrap_or_default(),
+            ))
         }
 
         fn import_from_vscode(_vscode: &VsCodeSettings, _current: &mut Self::FileContent) {}
@@ -2169,15 +2206,14 @@ mod tests {
         key2: String,
     }
 
-    #[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi)]
+    #[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey)]
+    #[settings_key(None)]
     struct MultiKeySettingsJson {
         key1: Option<String>,
         key2: Option<String>,
     }
 
     impl Settings for MultiKeySettings {
-        const KEY: Option<&'static str> = None;
-
         type FileContent = MultiKeySettingsJson;
 
         fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
@@ -2207,15 +2243,16 @@ mod tests {
         Hour24,
     }
 
-    #[derive(Clone, Default, Debug, Serialize, Deserialize, JsonSchema, SettingsUi)]
+    #[derive(
+        Clone, Default, Debug, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey,
+    )]
+    #[settings_key(key = "journal")]
     struct JournalSettingsJson {
         pub path: Option<String>,
         pub hour_format: Option<HourFormat>,
     }
 
     impl Settings for JournalSettings {
-        const KEY: Option<&'static str> = Some("journal");
-
         type FileContent = JournalSettingsJson;
 
         fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
@@ -2295,7 +2332,10 @@ mod tests {
         );
     }
 
-    #[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema, SettingsUi)]
+    #[derive(
+        Clone, Debug, Default, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey,
+    )]
+    #[settings_key(None)]
     struct LanguageSettings {
         #[serde(default)]
         languages: HashMap<String, LanguageSettingEntry>,
@@ -2308,8 +2348,6 @@ mod tests {
     }
 
     impl Settings for LanguageSettings {
-        const KEY: Option<&'static str> = None;
-
         type FileContent = Self;
 
         fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
diff --git a/crates/settings/src/settings_ui_core.rs b/crates/settings/src/settings_ui_core.rs
index 9086d3c7454465e8abcaf2d30d01a4f928e4ddef..09505e63a3ea960ce80ffcfbb63039fb53778469 100644
--- a/crates/settings/src/settings_ui_core.rs
+++ b/crates/settings/src/settings_ui_core.rs
@@ -1,8 +1,12 @@
-use std::any::TypeId;
+use std::{
+    any::TypeId,
+    num::{NonZeroU32, NonZeroUsize},
+    rc::Rc,
+};
 
 use anyhow::Context as _;
 use fs::Fs;
-use gpui::{AnyElement, App, AppContext as _, ReadGlobal as _, Window};
+use gpui::{AnyElement, App, AppContext as _, ReadGlobal as _, SharedString, Window};
 use smallvec::SmallVec;
 
 use crate::SettingsStore;
@@ -19,19 +23,24 @@ pub trait SettingsUi {
             path: None,
             title: "None entry",
             item: SettingsUiItem::None,
+            documentation: None,
         }
     }
 }
 
+#[derive(Clone)]
 pub struct SettingsUiEntry {
     /// The path in the settings JSON file for this setting. Relative to parent
     /// None implies `#[serde(flatten)]` or `Settings::KEY.is_none()` for top level settings
     pub path: Option<&'static str>,
     /// What is displayed for the text for this entry
     pub title: &'static str,
+    /// documentation for this entry. Constructed from the documentation comment above the struct or field
+    pub documentation: Option<&'static str>,
     pub item: SettingsUiItem,
 }
 
+#[derive(Clone)]
 pub enum SettingsUiItemSingle {
     SwitchField,
     /// A numeric stepper for a specific type of number
@@ -49,12 +58,13 @@ pub enum SettingsUiItemSingle {
         /// Must be the same length as `variants`
         labels: &'static [&'static str],
     },
-    Custom(Box<dyn Fn(SettingsValue<serde_json::Value>, &mut Window, &mut App) -> AnyElement>),
+    Custom(Rc<dyn Fn(SettingsValue<serde_json::Value>, &mut Window, &mut App) -> AnyElement>),
 }
 
 pub struct SettingsValue<T> {
-    pub title: &'static str,
-    pub path: SmallVec<[&'static str; 1]>,
+    pub title: SharedString,
+    pub documentation: Option<SharedString>,
+    pub path: SmallVec<[SharedString; 1]>,
     pub value: Option<T>,
     pub default_value: T,
 }
@@ -69,11 +79,12 @@ impl<T> SettingsValue<T> {
 }
 
 impl SettingsValue<serde_json::Value> {
-    pub fn write_value(path: &SmallVec<[&'static str; 1]>, value: serde_json::Value, cx: &mut App) {
+    pub fn write_value(path: &SmallVec<[SharedString; 1]>, value: serde_json::Value, cx: &mut App) {
         let settings_store = SettingsStore::global(cx);
         let fs = <dyn Fs>::global(cx);
 
         let rx = settings_store.update_settings_file_at_path(fs.clone(), path.as_slice(), value);
+
         let path = path.clone();
         cx.background_spawn(async move {
             rx.await?
@@ -85,7 +96,7 @@ impl SettingsValue<serde_json::Value> {
 
 impl<T: serde::Serialize> SettingsValue<T> {
     pub fn write(
-        path: &SmallVec<[&'static str; 1]>,
+        path: &SmallVec<[SharedString; 1]>,
         value: T,
         cx: &mut App,
     ) -> Result<(), serde_json::Error> {
@@ -94,19 +105,36 @@ impl<T: serde::Serialize> SettingsValue<T> {
     }
 }
 
-pub struct SettingsUiItemDynamic {
+#[derive(Clone)]
+pub struct SettingsUiItemUnion {
     pub options: Vec<SettingsUiEntry>,
     pub determine_option: fn(&serde_json::Value, &App) -> usize,
 }
 
+pub struct SettingsUiEntryMetaData {
+    pub title: SharedString,
+    pub path: SharedString,
+    pub documentation: Option<SharedString>,
+}
+
+#[derive(Clone)]
+pub struct SettingsUiItemDynamicMap {
+    pub item: fn() -> SettingsUiItem,
+    pub determine_items: fn(&serde_json::Value, &App) -> Vec<SettingsUiEntryMetaData>,
+    pub defaults_path: &'static [&'static str],
+}
+
+#[derive(Clone)]
 pub struct SettingsUiItemGroup {
     pub items: Vec<SettingsUiEntry>,
 }
 
+#[derive(Clone)]
 pub enum SettingsUiItem {
     Group(SettingsUiItemGroup),
     Single(SettingsUiItemSingle),
-    Dynamic(SettingsUiItemDynamic),
+    Union(SettingsUiItemUnion),
+    DynamicMap(SettingsUiItemDynamicMap),
     None,
 }
 
@@ -128,7 +156,10 @@ pub enum NumType {
     U64 = 0,
     U32 = 1,
     F32 = 2,
+    USIZE = 3,
+    U32NONZERO = 4,
 }
+
 pub static NUM_TYPE_NAMES: std::sync::LazyLock<[&'static str; NumType::COUNT]> =
     std::sync::LazyLock::new(|| NumType::ALL.map(NumType::type_name));
 pub static NUM_TYPE_IDS: std::sync::LazyLock<[TypeId; NumType::COUNT]> =
@@ -143,6 +174,8 @@ impl NumType {
             NumType::U64 => TypeId::of::<u64>(),
             NumType::U32 => TypeId::of::<u32>(),
             NumType::F32 => TypeId::of::<f32>(),
+            NumType::USIZE => TypeId::of::<usize>(),
+            NumType::U32NONZERO => TypeId::of::<NonZeroU32>(),
         }
     }
 
@@ -151,6 +184,8 @@ impl NumType {
             NumType::U64 => std::any::type_name::<u64>(),
             NumType::U32 => std::any::type_name::<u32>(),
             NumType::F32 => std::any::type_name::<f32>(),
+            NumType::USIZE => std::any::type_name::<usize>(),
+            NumType::U32NONZERO => std::any::type_name::<NonZeroU32>(),
         }
     }
 }
@@ -175,3 +210,5 @@ numeric_stepper_for_num_type!(u64, U64);
 numeric_stepper_for_num_type!(u32, U32);
 // todo(settings_ui) is there a better ui for f32?
 numeric_stepper_for_num_type!(f32, F32);
+numeric_stepper_for_num_type!(usize, USIZE);
+numeric_stepper_for_num_type!(NonZeroUsize, U32NONZERO);
diff --git a/crates/settings_ui/src/settings_ui.rs b/crates/settings_ui/src/settings_ui.rs
index f316a318785c7f56d465c2d39e6b6ea9bbbd1bfa..9866dcdb3eb7fe60697a383f25a21e0c8d51fa14 100644
--- a/crates/settings_ui/src/settings_ui.rs
+++ b/crates/settings_ui/src/settings_ui.rs
@@ -1,17 +1,18 @@
 mod appearance_settings_controls;
 
 use std::any::TypeId;
-use std::collections::VecDeque;
+use std::num::NonZeroU32;
 use std::ops::{Not, Range};
 
 use anyhow::Context as _;
 use command_palette_hooks::CommandPaletteFilter;
 use editor::EditorSettingsControls;
 use feature_flags::{FeatureFlag, FeatureFlagViewExt};
-use gpui::{App, Entity, EventEmitter, FocusHandle, Focusable, ReadGlobal, actions};
+use gpui::{App, Entity, EventEmitter, FocusHandle, Focusable, ReadGlobal, ScrollHandle, actions};
 use settings::{
-    NumType, SettingsStore, SettingsUiEntry, SettingsUiItem, SettingsUiItemDynamic,
-    SettingsUiItemGroup, SettingsUiItemSingle, SettingsValue,
+    NumType, SettingsStore, SettingsUiEntry, SettingsUiEntryMetaData, SettingsUiItem,
+    SettingsUiItemDynamicMap, SettingsUiItemGroup, SettingsUiItemSingle, SettingsUiItemUnion,
+    SettingsValue,
 };
 use smallvec::SmallVec;
 use ui::{NumericStepper, SwitchField, ToggleButtonGroup, ToggleButtonSimple, prelude::*};
@@ -71,7 +72,7 @@ pub fn init(cx: &mut App) {
             move |is_enabled, _workspace, _, cx| {
                 if is_enabled {
                     CommandPaletteFilter::update_global(cx, |filter, _cx| {
-                        filter.show_action_types(settings_ui_actions.iter());
+                        filter.show_action_types(&settings_ui_actions);
                     });
                 } else {
                     CommandPaletteFilter::update_global(cx, |filter, _cx| {
@@ -136,8 +137,9 @@ impl Item for SettingsPage {
 //   - Do we want to show the parent groups when a item is matched?
 
 struct UiEntry {
-    title: &'static str,
-    path: Option<&'static str>,
+    title: SharedString,
+    path: Option<SharedString>,
+    documentation: Option<SharedString>,
     _depth: usize,
     // a
     //  b     < a descendant range < a total descendant range
@@ -154,6 +156,11 @@ struct UiEntry {
     /// For dynamic items this is a way to select a value from a list of values
     /// this is always none for non-dynamic items
     select_descendant: Option<fn(&serde_json::Value, &App) -> usize>,
+    generate_items: Option<(
+        SettingsUiItem,
+        fn(&serde_json::Value, &App) -> Vec<SettingsUiEntryMetaData>,
+        SmallVec<[SharedString; 1]>,
+    )>,
 }
 
 impl UiEntry {
@@ -193,14 +200,16 @@ fn build_tree_item(
 ) {
     let index = tree.len();
     tree.push(UiEntry {
-        title: entry.title,
-        path: entry.path,
+        title: entry.title.into(),
+        path: entry.path.map(SharedString::new_static),
+        documentation: entry.documentation.map(SharedString::new_static),
         _depth: depth,
         descendant_range: index + 1..index + 1,
         total_descendant_range: index + 1..index + 1,
         render: None,
         next_sibling: None,
         select_descendant: None,
+        generate_items: None,
     });
     if let Some(prev_index) = prev_index {
         tree[prev_index].next_sibling = Some(index);
@@ -221,7 +230,7 @@ fn build_tree_item(
         SettingsUiItem::Single(item) => {
             tree[index].render = Some(item);
         }
-        SettingsUiItem::Dynamic(SettingsUiItemDynamic {
+        SettingsUiItem::Union(SettingsUiItemUnion {
             options,
             determine_option,
         }) => {
@@ -237,6 +246,21 @@ fn build_tree_item(
                 tree[index].total_descendant_range.end = tree.len();
             }
         }
+        SettingsUiItem::DynamicMap(SettingsUiItemDynamicMap {
+            item: generate_settings_ui_item,
+            determine_items,
+            defaults_path,
+        }) => {
+            tree[index].generate_items = Some((
+                generate_settings_ui_item(),
+                determine_items,
+                defaults_path
+                    .into_iter()
+                    .copied()
+                    .map(SharedString::new_static)
+                    .collect(),
+            ));
+        }
         SettingsUiItem::None => {
             return;
         }
@@ -262,7 +286,7 @@ impl SettingsUiTree {
             build_tree_item(&mut tree, item, 0, prev_root_entry_index);
         }
 
-        root_entry_indices.sort_by_key(|i| tree[*i].title);
+        root_entry_indices.sort_by_key(|i| &tree[*i].title);
 
         let active_entry_index = root_entry_indices[0];
         Self {
@@ -275,18 +299,18 @@ impl SettingsUiTree {
     // todo(settings_ui): Make sure `Item::None` paths are added to the paths tree,
     // so that we can keep none/skip and still test in CI that all settings have
     #[cfg(feature = "test-support")]
-    pub fn all_paths(&self, cx: &App) -> Vec<Vec<&'static str>> {
+    pub fn all_paths(&self, cx: &App) -> Vec<Vec<SharedString>> {
         fn all_paths_rec(
             tree: &[UiEntry],
-            paths: &mut Vec<Vec<&'static str>>,
-            current_path: &mut Vec<&'static str>,
+            paths: &mut Vec<Vec<SharedString>>,
+            current_path: &mut Vec<SharedString>,
             idx: usize,
             cx: &App,
         ) {
             let child = &tree[idx];
             let mut pushed_path = false;
             if let Some(path) = child.path.as_ref() {
-                current_path.push(path);
+                current_path.push(path.clone());
                 paths.push(current_path.clone());
                 pushed_path = true;
             }
@@ -339,7 +363,7 @@ fn render_nav(tree: &SettingsUiTree, _window: &mut Window, cx: &mut Context<Sett
                     settings.settings_tree.active_entry_index = index;
                 }))
                 .child(
-                    Label::new(SharedString::new_static(tree.entries[index].title))
+                    Label::new(tree.entries[index].title.clone())
                         .size(LabelSize::Large)
                         .when(tree.active_entry_index == index, |this| {
                             this.color(Color::Selected)
@@ -354,71 +378,156 @@ fn render_content(
     tree: &SettingsUiTree,
     window: &mut Window,
     cx: &mut Context<SettingsPage>,
-) -> impl IntoElement {
-    let Some(active_entry) = tree.entries.get(tree.active_entry_index) else {
-        return div()
-            .size_full()
-            .child(Label::new(SharedString::new_static("No settings found")).color(Color::Error));
-    };
-    let mut content = v_flex().size_full().gap_4().overflow_hidden();
+) -> Div {
+    let content = v_flex().size_full().gap_4();
 
     let mut path = smallvec::smallvec![];
-    if let Some(active_entry_path) = active_entry.path {
-        path.push(active_entry_path);
-    }
-    let mut entry_index_queue = VecDeque::new();
-
-    if let Some(child_index) = active_entry.first_descendant_index() {
-        entry_index_queue.push_back(child_index);
-        let mut index = child_index;
-        while let Some(next_sibling_index) = tree.entries[index].next_sibling {
-            entry_index_queue.push_back(next_sibling_index);
-            index = next_sibling_index;
-        }
-    };
 
-    while let Some(index) = entry_index_queue.pop_front() {
+    fn render_recursive(
+        tree: &[UiEntry],
+        index: usize,
+        path: &mut SmallVec<[SharedString; 1]>,
+        mut element: Div,
+        // todo(settings_ui): can this be a ref without cx borrow issues?
+        fallback_path: &mut Option<SmallVec<[SharedString; 1]>>,
+        window: &mut Window,
+        cx: &mut App,
+    ) -> Div {
+        let Some(child) = tree.get(index) else {
+            return element.child(
+                Label::new(SharedString::new_static("No settings found")).color(Color::Error),
+            );
+        };
+
+        element = element.child(Label::new(child.title.clone()).size(LabelSize::Large));
+
         // todo(settings_ui): subgroups?
-        let child = &tree.entries[index];
         let mut pushed_path = false;
-        if let Some(child_path) = child.path {
-            path.push(child_path);
+        if let Some(child_path) = child.path.as_ref() {
+            path.push(child_path.clone());
+            if let Some(fallback_path) = fallback_path.as_mut() {
+                fallback_path.push(child_path.clone());
+            }
             pushed_path = true;
         }
+        // let fallback_path_copy = fallback_path.cloned();
         let settings_value = settings_value_from_settings_and_path(
             path.clone(),
-            child.title,
+            fallback_path.as_ref().map(|path| path.as_slice()),
+            child.title.clone(),
+            child.documentation.clone(),
             // PERF: how to structure this better? There feels like there's a way to avoid the clone
             // and every value lookup
             SettingsStore::global(cx).raw_user_settings(),
             SettingsStore::global(cx).raw_default_settings(),
         );
         if let Some(select_descendant) = child.select_descendant {
-            let selected_descendant = select_descendant(settings_value.read(), cx);
-            if let Some(descendant_index) =
-                child.nth_descendant_index(&tree.entries, selected_descendant)
-            {
-                entry_index_queue.push_front(descendant_index);
+            let selected_descendant =
+                child.nth_descendant_index(tree, select_descendant(settings_value.read(), cx));
+            if let Some(descendant_index) = selected_descendant {
+                element = render_recursive(
+                    tree,
+                    descendant_index,
+                    path,
+                    element,
+                    fallback_path,
+                    window,
+                    cx,
+                );
             }
+        } else if let Some((settings_ui_item, generate_items, defaults_path)) =
+            child.generate_items.as_ref()
+        {
+            let generated_items = generate_items(settings_value.read(), cx);
+            let mut ui_items = Vec::with_capacity(generated_items.len());
+            for item in generated_items {
+                let settings_ui_entry = SettingsUiEntry {
+                    path: None,
+                    title: "",
+                    documentation: None,
+                    item: settings_ui_item.clone(),
+                };
+                let prev_index = if ui_items.is_empty() {
+                    None
+                } else {
+                    Some(ui_items.len() - 1)
+                };
+                let item_index = ui_items.len();
+                build_tree_item(
+                    &mut ui_items,
+                    settings_ui_entry,
+                    child._depth + 1,
+                    prev_index,
+                );
+                if item_index < ui_items.len() {
+                    ui_items[item_index].path = None;
+                    ui_items[item_index].title = item.title.clone();
+                    ui_items[item_index].documentation = item.documentation.clone();
+
+                    // push path instead of setting path on ui item so that the path isn't pushed to default_path as well
+                    // when we recurse
+                    path.push(item.path.clone());
+                    element = render_recursive(
+                        &ui_items,
+                        item_index,
+                        path,
+                        element,
+                        &mut Some(defaults_path.clone()),
+                        window,
+                        cx,
+                    );
+                    path.pop();
+                }
+            }
+        } else if let Some(child_render) = child.render.as_ref() {
+            element = element.child(div().child(render_item_single(
+                settings_value,
+                child_render,
+                window,
+                cx,
+            )));
+        } else if let Some(child_index) = child.first_descendant_index() {
+            let mut index = Some(child_index);
+            while let Some(sub_child_index) = index {
+                element = render_recursive(
+                    tree,
+                    sub_child_index,
+                    path,
+                    element,
+                    fallback_path,
+                    window,
+                    cx,
+                );
+                index = tree[sub_child_index].next_sibling;
+            }
+        } else {
+            element =
+                element.child(div().child(Label::new("// skipped (for now)").color(Color::Muted)))
         }
+
         if pushed_path {
             path.pop();
+            if let Some(fallback_path) = fallback_path.as_mut() {
+                fallback_path.pop();
+            }
         }
-        let Some(child_render) = child.render.as_ref() else {
-            continue;
-        };
-        content = content.child(
-            div()
-                .child(Label::new(SharedString::new_static(child.title)).size(LabelSize::Large))
-                .child(render_item_single(settings_value, child_render, window, cx)),
-        );
+        return element;
     }
 
-    return content;
+    return render_recursive(
+        &tree.entries,
+        tree.active_entry_index,
+        &mut path,
+        content,
+        &mut None,
+        window,
+        cx,
+    );
 }
 
 impl Render for SettingsPage {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let scroll_handle = window.use_state(cx, |_, _| ScrollHandle::new());
         div()
             .grid()
             .grid_cols(16)
@@ -427,15 +536,19 @@ impl Render for SettingsPage {
             .size_full()
             .child(
                 div()
+                    .id("settings-ui-nav")
                     .col_span(2)
                     .h_full()
                     .child(render_nav(&self.settings_tree, window, cx)),
             )
-            .child(div().col_span(4).h_full().child(render_content(
-                &self.settings_tree,
-                window,
-                cx,
-            )))
+            .child(
+                div().col_span(6).h_full().child(
+                    render_content(&self.settings_tree, window, cx)
+                        .id("settings-ui-content")
+                        .track_scroll(scroll_handle.read(cx))
+                        .overflow_y_scroll(),
+                ),
+            )
     }
 }
 
@@ -463,15 +576,15 @@ fn render_old_appearance_settings(cx: &mut App) -> impl IntoElement {
         )
 }
 
-fn element_id_from_path(path: &[&'static str]) -> ElementId {
+fn element_id_from_path(path: &[SharedString]) -> ElementId {
     if path.len() == 0 {
         panic!("Path length must not be zero");
     } else if path.len() == 1 {
-        ElementId::Name(SharedString::new_static(path[0]))
+        ElementId::Name(path[0].clone())
     } else {
         ElementId::from((
-            ElementId::from(SharedString::new_static(path[path.len() - 2])),
-            SharedString::new_static(path[path.len() - 1]),
+            ElementId::from(path[path.len() - 2].clone()),
+            path[path.len() - 1].clone(),
         ))
     }
 }
@@ -504,13 +617,13 @@ fn render_item_single(
 
 pub fn read_settings_value_from_path<'a>(
     settings_contents: &'a serde_json::Value,
-    path: &[&str],
+    path: &[impl AsRef<str>],
 ) -> Option<&'a serde_json::Value> {
     // todo(settings_ui) make non recursive, and move to `settings` alongside SettingsValue, and add method to SettingsValue to get nested
     let Some((key, remaining)) = path.split_first() else {
         return Some(settings_contents);
     };
-    let Some(value) = settings_contents.get(key) else {
+    let Some(value) = settings_contents.get(key.as_ref()) else {
         return None;
     };
 
@@ -520,16 +633,21 @@ pub fn read_settings_value_from_path<'a>(
 fn downcast_any_item<T: serde::de::DeserializeOwned>(
     settings_value: SettingsValue<serde_json::Value>,
 ) -> SettingsValue<T> {
-    let value = settings_value
-        .value
-        .map(|value| serde_json::from_value::<T>(value).expect("value is not a T"));
+    let value = settings_value.value.map(|value| {
+        serde_json::from_value::<T>(value.clone())
+            .with_context(|| format!("path: {:?}", settings_value.path.join(".")))
+            .with_context(|| format!("value is not a {}: {}", std::any::type_name::<T>(), value))
+            .unwrap()
+    });
     // todo(settings_ui) Create test that constructs UI tree, and asserts that all elements have default values
     let default_value = serde_json::from_value::<T>(settings_value.default_value)
         .with_context(|| format!("path: {:?}", settings_value.path.join(".")))
-        .expect("default value is not an Option<T>");
+        .with_context(|| format!("value is not a {}", std::any::type_name::<T>()))
+        .unwrap();
     let deserialized_setting_value = SettingsValue {
         title: settings_value.title,
         path: settings_value.path,
+        documentation: settings_value.documentation,
         value,
         default_value,
     };
@@ -555,8 +673,8 @@ fn render_any_numeric_stepper(
     match num_type {
         NumType::U64 => render_numeric_stepper::<u64>(
             downcast_any_item(settings_value),
-            u64::saturating_sub,
-            u64::saturating_add,
+            |n| u64::saturating_sub(n, 1),
+            |n| u64::saturating_add(n, 1),
             |n| {
                 serde_json::Number::try_from(n)
                     .context("Failed to convert u64 to serde_json::Number")
@@ -566,8 +684,8 @@ fn render_any_numeric_stepper(
         ),
         NumType::U32 => render_numeric_stepper::<u32>(
             downcast_any_item(settings_value),
-            u32::saturating_sub,
-            u32::saturating_add,
+            |n| u32::saturating_sub(n, 1),
+            |n| u32::saturating_add(n, 1),
             |n| {
                 serde_json::Number::try_from(n)
                     .context("Failed to convert u32 to serde_json::Number")
@@ -577,8 +695,8 @@ fn render_any_numeric_stepper(
         ),
         NumType::F32 => render_numeric_stepper::<f32>(
             downcast_any_item(settings_value),
-            |a, b| a - b,
-            |a, b| a + b,
+            |a| a - 1.0,
+            |a| a + 1.0,
             |n| {
                 serde_json::Number::from_f64(n as f64)
                     .context("Failed to convert f32 to serde_json::Number")
@@ -586,15 +704,35 @@ fn render_any_numeric_stepper(
             window,
             cx,
         ),
+        NumType::USIZE => render_numeric_stepper::<usize>(
+            downcast_any_item(settings_value),
+            |n| usize::saturating_sub(n, 1),
+            |n| usize::saturating_add(n, 1),
+            |n| {
+                serde_json::Number::try_from(n)
+                    .context("Failed to convert usize to serde_json::Number")
+            },
+            window,
+            cx,
+        ),
+        NumType::U32NONZERO => render_numeric_stepper::<NonZeroU32>(
+            downcast_any_item(settings_value),
+            |a| NonZeroU32::new(u32::saturating_sub(a.get(), 1)).unwrap_or(NonZeroU32::MIN),
+            |a| NonZeroU32::new(u32::saturating_add(a.get(), 1)).unwrap_or(NonZeroU32::MAX),
+            |n| {
+                serde_json::Number::try_from(n.get())
+                    .context("Failed to convert usize to serde_json::Number")
+            },
+            window,
+            cx,
+        ),
     }
 }
 
-fn render_numeric_stepper<
-    T: serde::de::DeserializeOwned + std::fmt::Display + Copy + From<u8> + 'static,
->(
+fn render_numeric_stepper<T: serde::de::DeserializeOwned + std::fmt::Display + Copy + 'static>(
     value: SettingsValue<T>,
-    saturating_sub: fn(T, T) -> T,
-    saturating_add: fn(T, T) -> T,
+    saturating_sub_1: fn(T) -> T,
+    saturating_add_1: fn(T) -> T,
     to_serde_number: fn(T) -> anyhow::Result<serde_json::Number>,
     _window: &mut Window,
     _cx: &mut App,
@@ -607,9 +745,9 @@ fn render_numeric_stepper<
         id,
         num.to_string(),
         {
-            let path = value.path.clone();
+            let path = value.path;
             move |_, _, cx| {
-                let Some(number) = to_serde_number(saturating_sub(num, 1.into())).ok() else {
+                let Some(number) = to_serde_number(saturating_sub_1(num)).ok() else {
                     return;
                 };
                 let new_value = serde_json::Value::Number(number);
@@ -617,7 +755,7 @@ fn render_numeric_stepper<
             }
         },
         move |_, _, cx| {
-            let Some(number) = to_serde_number(saturating_add(num, 1.into())).ok() else {
+            let Some(number) = to_serde_number(saturating_add_1(num)).ok() else {
                 return;
             };
 
@@ -639,8 +777,8 @@ fn render_switch_field(
     let path = value.path.clone();
     SwitchField::new(
         id,
-        SharedString::new_static(value.title),
-        None,
+        value.title.clone(),
+        value.documentation.clone(),
         match value.read() {
             true => ToggleState::Selected,
             false => ToggleState::Unselected,
@@ -670,7 +808,6 @@ fn render_toggle_button_group(
     let value = downcast_any_item::<String>(value);
 
     fn make_toggle_group<const LEN: usize>(
-        group_name: &'static str,
         value: SettingsValue<String>,
         variants: &'static [&'static str],
         labels: &'static [&'static str],
@@ -694,7 +831,7 @@ fn render_toggle_button_group(
 
         let mut idx = 0;
         ToggleButtonGroup::single_row(
-            group_name,
+            value.title.clone(),
             variants_array.map(|(variant, label)| {
                 let path = value.path.clone();
                 idx += 1;
@@ -715,7 +852,7 @@ fn render_toggle_button_group(
     macro_rules! templ_toggl_with_const_param {
         ($len:expr) => {
             if variants.len() == $len {
-                return make_toggle_group::<$len>(value.title, value, variants, labels);
+                return make_toggle_group::<$len>(value, variants, labels);
             }
         };
     }
@@ -729,12 +866,19 @@ fn render_toggle_button_group(
 }
 
 fn settings_value_from_settings_and_path(
-    path: SmallVec<[&'static str; 1]>,
-    title: &'static str,
+    path: SmallVec<[SharedString; 1]>,
+    fallback_path: Option<&[SharedString]>,
+    title: SharedString,
+    documentation: Option<SharedString>,
     user_settings: &serde_json::Value,
     default_settings: &serde_json::Value,
 ) -> SettingsValue<serde_json::Value> {
     let default_value = read_settings_value_from_path(default_settings, &path)
+        .or_else(|| {
+            fallback_path.and_then(|fallback_path| {
+                read_settings_value_from_path(default_settings, fallback_path)
+            })
+        })
         .with_context(|| format!("No default value for item at path {:?}", path.join(".")))
         .expect("Default value set for item")
         .clone();
@@ -743,7 +887,8 @@ fn settings_value_from_settings_and_path(
     let settings_value = SettingsValue {
         default_value,
         value,
-        path: path.clone(),
+        documentation,
+        path,
         // todo(settings_ui) is title required inside SettingsValue?
         title,
     };
diff --git a/crates/settings_ui_macros/src/settings_ui_macros.rs b/crates/settings_ui_macros/src/settings_ui_macros.rs
index c98705d5f8d4de3f42b4756a32353123f5779fbc..076f9c0f04e2963e9f4732a1fc7177f9ab85c723 100644
--- a/crates/settings_ui_macros/src/settings_ui_macros.rs
+++ b/crates/settings_ui_macros/src/settings_ui_macros.rs
@@ -1,3 +1,5 @@
+use std::ops::Not;
+
 use heck::{ToSnakeCase as _, ToTitleCase as _};
 use proc_macro2::TokenStream;
 use quote::{ToTokens, quote};
@@ -43,10 +45,9 @@ pub fn derive_settings_ui(input: proc_macro::TokenStream) -> proc_macro::TokenSt
                     let lit: LitStr = meta.input.parse()?;
                     group_name = Some(lit.value());
                 } else if meta.path.is_ident("path") {
-                    // todo(settings_ui) try get KEY from Settings if possible, and once we do,
-                    // if can get key from settings, throw error if path also passed
+                    // todo(settings_ui) rely entirely on settings_key, remove path attribute
                     if path_name.is_some() {
-                        return Err(meta.error("Only one 'path' can be specified"));
+                        return Err(meta.error("Only one 'path' can be specified, either with `path` in `settings_ui` or with `settings_key`"));
                     }
                     meta.input.parse::<Token![=]>()?;
                     let lit: LitStr = meta.input.parse()?;
@@ -55,15 +56,28 @@ pub fn derive_settings_ui(input: proc_macro::TokenStream) -> proc_macro::TokenSt
                 Ok(())
             })
             .unwrap_or_else(|e| panic!("in #[settings_ui] attribute: {}", e));
+        } else if let Some(settings_key) = parse_setting_key_attr(attr) {
+            // todo(settings_ui) either remove fallback key or handle it here
+            if path_name.is_some() && settings_key.key.is_some() {
+                panic!("Both 'path' and 'settings_key' are specified. Must specify only one");
+            }
+            path_name = settings_key.key;
         }
     }
 
+    let doc_str = parse_documentation_from_attrs(&input.attrs);
+
     let ui_item_fn_body = generate_ui_item_body(group_name.as_ref(), path_name.as_ref(), &input);
 
     // todo(settings_ui): make group name optional, repurpose group as tag indicating item is group, and have "title" tag for custom title
     let title = group_name.unwrap_or(input.ident.to_string().to_title_case());
 
-    let ui_entry_fn_body = map_ui_item_to_entry(path_name.as_deref(), &title, quote! { Self });
+    let ui_entry_fn_body = map_ui_item_to_entry(
+        path_name.as_deref(),
+        &title,
+        doc_str.as_deref(),
+        quote! { Self },
+    );
 
     let expanded = quote! {
         impl #impl_generics settings::SettingsUi for #name #ty_generics #where_clause {
@@ -106,14 +120,22 @@ fn option_inner_type(ty: TokenStream) -> Option<TokenStream> {
     return Some(ty.to_token_stream());
 }
 
-fn map_ui_item_to_entry(path: Option<&str>, title: &str, ty: TokenStream) -> TokenStream {
+fn map_ui_item_to_entry(
+    path: Option<&str>,
+    title: &str,
+    doc_str: Option<&str>,
+    ty: TokenStream,
+) -> TokenStream {
     let ty = extract_type_from_option(ty);
+    // todo(settings_ui): does quote! just work with options?
     let path = path.map_or_else(|| quote! {None}, |path| quote! {Some(#path)});
+    let doc_str = doc_str.map_or_else(|| quote! {None}, |doc_str| quote! {Some(#doc_str)});
     quote! {
         settings::SettingsUiEntry {
             title: #title,
             path: #path,
             item: #ty::settings_ui_item(),
+            documentation: #doc_str,
         }
     }
 }
@@ -129,6 +151,7 @@ fn generate_ui_item_body(
             settings::SettingsUiItem::None
         },
         (Some(_), _, Data::Struct(data_struct)) => {
+            let struct_serde_attrs = parse_serde_attributes(&input.attrs);
             let fields = data_struct
                 .fields
                 .iter()
@@ -148,48 +171,37 @@ fn generate_ui_item_body(
                     })
                 })
                 .map(|field| {
+                    let field_serde_attrs = parse_serde_attributes(&field.attrs);
+                    let name = field.ident.clone().expect("tuple fields").to_string();
+                    let doc_str = parse_documentation_from_attrs(&field.attrs);
+
                     (
-                        field.ident.clone().expect("tuple fields").to_string(),
+                        name.to_title_case(),
+                        doc_str,
+                        field_serde_attrs.flatten.not().then(|| {
+                            struct_serde_attrs.apply_rename_to_field(&field_serde_attrs, &name)
+                        }),
                         field.ty.to_token_stream(),
                     )
                 })
                 // todo(settings_ui): Re-format field name as nice title, and support setting different title with attr
-                .map(|(name, ty)| map_ui_item_to_entry(Some(&name), &name.to_title_case(), ty));
+                .map(|(title, doc_str, path, ty)| {
+                    map_ui_item_to_entry(path.as_deref(), &title, doc_str.as_deref(), ty)
+                });
 
             quote! {
                 settings::SettingsUiItem::Group(settings::SettingsUiItemGroup{ items: vec![#(#fields),*] })
             }
         }
         (None, _, Data::Enum(data_enum)) => {
-            let mut lowercase = false;
-            let mut snake_case = false;
-            for attr in &input.attrs {
-                if attr.path().is_ident("serde") {
-                    attr.parse_nested_meta(|meta| {
-                        if meta.path.is_ident("rename_all") {
-                            meta.input.parse::<Token![=]>()?;
-                            let lit = meta.input.parse::<LitStr>()?.value();
-                            lowercase = lit == "lowercase";
-                            snake_case = lit == "snake_case";
-                        }
-                        Ok(())
-                    })
-                    .ok();
-                }
-            }
+            let serde_attrs = parse_serde_attributes(&input.attrs);
             let length = data_enum.variants.len();
 
             let variants = data_enum.variants.iter().map(|variant| {
                 let string = variant.ident.clone().to_string();
 
                 let title = string.to_title_case();
-                let string = if lowercase {
-                    string.to_lowercase()
-                } else if snake_case {
-                    string.to_snake_case()
-                } else {
-                    string
-                };
+                let string = serde_attrs.rename_all.apply(&string);
 
                 (string, title)
             });
@@ -212,3 +224,233 @@ fn generate_ui_item_body(
         },
     }
 }
+
+struct SerdeOptions {
+    rename_all: SerdeRenameAll,
+    rename: Option<String>,
+    flatten: bool,
+    _alias: Option<String>, // todo(settings_ui)
+}
+
+#[derive(PartialEq)]
+enum SerdeRenameAll {
+    Lowercase,
+    SnakeCase,
+    None,
+}
+
+impl SerdeRenameAll {
+    fn apply(&self, name: &str) -> String {
+        match self {
+            SerdeRenameAll::Lowercase => name.to_lowercase(),
+            SerdeRenameAll::SnakeCase => name.to_snake_case(),
+            SerdeRenameAll::None => name.to_string(),
+        }
+    }
+}
+
+impl SerdeOptions {
+    fn apply_rename_to_field(&self, field_options: &Self, name: &str) -> String {
+        // field renames take precedence over struct rename all cases
+        if let Some(rename) = &field_options.rename {
+            return rename.clone();
+        }
+        return self.rename_all.apply(name);
+    }
+}
+
+fn parse_serde_attributes(attrs: &[syn::Attribute]) -> SerdeOptions {
+    let mut options = SerdeOptions {
+        rename_all: SerdeRenameAll::None,
+        rename: None,
+        flatten: false,
+        _alias: None,
+    };
+
+    for attr in attrs {
+        if !attr.path().is_ident("serde") {
+            continue;
+        }
+        attr.parse_nested_meta(|meta| {
+            if meta.path.is_ident("rename_all") {
+                meta.input.parse::<Token![=]>()?;
+                let lit = meta.input.parse::<LitStr>()?.value();
+
+                if options.rename_all != SerdeRenameAll::None {
+                    return Err(meta.error("duplicate `rename_all` attribute"));
+                } else if lit == "lowercase" {
+                    options.rename_all = SerdeRenameAll::Lowercase;
+                } else if lit == "snake_case" {
+                    options.rename_all = SerdeRenameAll::SnakeCase;
+                } else {
+                    return Err(meta.error(format!("invalid `rename_all` attribute: {}", lit)));
+                }
+                // todo(settings_ui): Other options?
+            } else if meta.path.is_ident("flatten") {
+                options.flatten = true;
+            } else if meta.path.is_ident("rename") {
+                if options.rename.is_some() {
+                    return Err(meta.error("Can only have one rename attribute"));
+                }
+
+                meta.input.parse::<Token![=]>()?;
+                let lit = meta.input.parse::<LitStr>()?.value();
+                options.rename = Some(lit);
+            }
+            Ok(())
+        })
+        .unwrap();
+    }
+
+    return options;
+}
+
+fn parse_documentation_from_attrs(attrs: &[syn::Attribute]) -> Option<String> {
+    let mut doc_str = Option::<String>::None;
+    for attr in attrs {
+        if attr.path().is_ident("doc") {
+            // /// ...
+            // becomes
+            // #[doc = "..."]
+            use syn::{Expr::Lit, ExprLit, Lit::Str, Meta, MetaNameValue};
+            if let Meta::NameValue(MetaNameValue {
+                value:
+                    Lit(ExprLit {
+                        lit: Str(ref lit_str),
+                        ..
+                    }),
+                ..
+            }) = attr.meta
+            {
+                let doc = lit_str.value();
+                let doc_str = doc_str.get_or_insert_default();
+                doc_str.push_str(doc.trim());
+                doc_str.push('\n');
+            }
+        }
+    }
+    return doc_str;
+}
+
+struct SettingsKey {
+    key: Option<String>,
+    fallback_key: Option<String>,
+}
+
+fn parse_setting_key_attr(attr: &syn::Attribute) -> Option<SettingsKey> {
+    if !attr.path().is_ident("settings_key") {
+        return None;
+    }
+
+    let mut settings_key = SettingsKey {
+        key: None,
+        fallback_key: None,
+    };
+
+    let mut found_none = false;
+
+    attr.parse_nested_meta(|meta| {
+        if meta.path.is_ident("None") {
+            found_none = true;
+        } else if meta.path.is_ident("key") {
+            if settings_key.key.is_some() {
+                return Err(meta.error("Only one 'group' path can be specified"));
+            }
+            meta.input.parse::<Token![=]>()?;
+            let lit: LitStr = meta.input.parse()?;
+            settings_key.key = Some(lit.value());
+        } else if meta.path.is_ident("fallback_key") {
+            if found_none {
+                return Err(meta.error("Cannot specify 'fallback_key' and 'None'"));
+            }
+
+            if settings_key.fallback_key.is_some() {
+                return Err(meta.error("Only one 'fallback_key' can be specified"));
+            }
+
+            meta.input.parse::<Token![=]>()?;
+            let lit: LitStr = meta.input.parse()?;
+            settings_key.fallback_key = Some(lit.value());
+        }
+        Ok(())
+    })
+    .unwrap_or_else(|e| panic!("in #[settings_key] attribute: {}", e));
+
+    if found_none && settings_key.fallback_key.is_some() {
+        panic!("in #[settings_key] attribute: Cannot specify 'None' and 'fallback_key'");
+    }
+    if found_none && settings_key.key.is_some() {
+        panic!("in #[settings_key] attribute: Cannot specify 'None' and 'key'");
+    }
+    if !found_none && settings_key.key.is_none() {
+        panic!("in #[settings_key] attribute: 'key' must be specified");
+    }
+
+    return Some(settings_key);
+}
+
+#[proc_macro_derive(SettingsKey, attributes(settings_key))]
+pub fn derive_settings_key(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = &input.ident;
+
+    // Handle generic parameters if present
+    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+
+    let mut settings_key = Option::<SettingsKey>::None;
+
+    for attr in &input.attrs {
+        let parsed_settings_key = parse_setting_key_attr(attr);
+        if parsed_settings_key.is_some() && settings_key.is_some() {
+            panic!("Duplicate #[settings_key] attribute");
+        }
+        settings_key = settings_key.or(parsed_settings_key);
+    }
+
+    let Some(SettingsKey { key, fallback_key }) = settings_key else {
+        panic!("Missing #[settings_key] attribute");
+    };
+
+    let key = key.map_or_else(|| quote! {None}, |key| quote! {Some(#key)});
+    let fallback_key = fallback_key.map_or_else(
+        || quote! {None},
+        |fallback_key| quote! {Some(#fallback_key)},
+    );
+
+    let expanded = quote! {
+        impl #impl_generics settings::SettingsKey for #name #ty_generics #where_clause {
+            const KEY: Option<&'static str> = #key;
+
+            const FALLBACK_KEY: Option<&'static str> = #fallback_key;
+        };
+    };
+
+    proc_macro::TokenStream::from(expanded)
+}
+
+#[cfg(test)]
+mod tests {
+    use syn::{Attribute, parse_quote};
+
+    use super::*;
+
+    #[test]
+    fn test_extract_key() {
+        let input: Attribute = parse_quote!(
+            #[settings_key(key = "my_key")]
+        );
+        let settings_key = parse_setting_key_attr(&input).unwrap();
+        assert_eq!(settings_key.key, Some("my_key".to_string()));
+        assert_eq!(settings_key.fallback_key, None);
+    }
+
+    #[test]
+    fn test_empty_key() {
+        let input: Attribute = parse_quote!(
+            #[settings_key(None)]
+        );
+        let settings_key = parse_setting_key_attr(&input).unwrap();
+        assert_eq!(settings_key.key, None);
+        assert_eq!(settings_key.fallback_key, None);
+    }
+}
diff --git a/crates/sqlez/Cargo.toml b/crates/sqlez/Cargo.toml
index 16a3adebae24e0573f9e7ada18bc9259ff588ad1..6eb75aa171979283325d22300f95d584cee2cffb 100644
--- a/crates/sqlez/Cargo.toml
+++ b/crates/sqlez/Cargo.toml
@@ -14,6 +14,7 @@ collections.workspace = true
 futures.workspace = true
 indoc.workspace = true
 libsqlite3-sys.workspace = true
+log.workspace = true
 parking_lot.workspace = true
 smol.workspace = true
 sqlformat.workspace = true
diff --git a/crates/sqlez/src/connection.rs b/crates/sqlez/src/connection.rs
index 228bd4c6a2df31f41dc1988596fc87323063d78c..53f0d4e2614f340cc0563d5cd9374bdc3626d9bb 100644
--- a/crates/sqlez/src/connection.rs
+++ b/crates/sqlez/src/connection.rs
@@ -92,91 +92,97 @@ impl Connection {
         let mut remaining_sql = sql.as_c_str();
         let sql_start = remaining_sql.as_ptr();
 
-        unsafe {
-            let mut alter_table = None;
-            while {
-                let remaining_sql_str = remaining_sql.to_str().unwrap().trim();
-                let any_remaining_sql = remaining_sql_str != ";" && !remaining_sql_str.is_empty();
-                if any_remaining_sql {
-                    alter_table = parse_alter_table(remaining_sql_str);
+        let mut alter_table = None;
+        while {
+            let remaining_sql_str = remaining_sql.to_str().unwrap().trim();
+            let any_remaining_sql = remaining_sql_str != ";" && !remaining_sql_str.is_empty();
+            if any_remaining_sql {
+                alter_table = parse_alter_table(remaining_sql_str);
+            }
+            any_remaining_sql
+        } {
+            let mut raw_statement = ptr::null_mut::<sqlite3_stmt>();
+            let mut remaining_sql_ptr = ptr::null();
+
+            let (res, offset, message, _conn) = if let Some((table_to_alter, column)) = alter_table
+            {
+                // ALTER TABLE is a weird statement. When preparing the statement the table's
+                // existence is checked *before* syntax checking any other part of the statement.
+                // Therefore, we need to make sure that the table has been created before calling
+                // prepare. As we don't want to trash whatever database this is connected to, we
+                // create a new in-memory DB to test.
+
+                let temp_connection = Connection::open_memory(None);
+                //This should always succeed, if it doesn't then you really should know about it
+                temp_connection
+                    .exec(&format!("CREATE TABLE {table_to_alter}({column})"))
+                    .unwrap()()
+                .unwrap();
+
+                unsafe {
+                    sqlite3_prepare_v2(
+                        temp_connection.sqlite3,
+                        remaining_sql.as_ptr(),
+                        -1,
+                        &mut raw_statement,
+                        &mut remaining_sql_ptr,
+                    )
+                };
+
+                #[cfg(not(any(target_os = "linux", target_os = "freebsd")))]
+                let offset = unsafe { sqlite3_error_offset(temp_connection.sqlite3) };
+
+                #[cfg(any(target_os = "linux", target_os = "freebsd"))]
+                let offset = 0;
+
+                unsafe {
+                    (
+                        sqlite3_errcode(temp_connection.sqlite3),
+                        offset,
+                        sqlite3_errmsg(temp_connection.sqlite3),
+                        Some(temp_connection),
+                    )
                 }
-                any_remaining_sql
-            } {
-                let mut raw_statement = ptr::null_mut::<sqlite3_stmt>();
-                let mut remaining_sql_ptr = ptr::null();
-
-                let (res, offset, message, _conn) =
-                    if let Some((table_to_alter, column)) = alter_table {
-                        // ALTER TABLE is a weird statement. When preparing the statement the table's
-                        // existence is checked *before* syntax checking any other part of the statement.
-                        // Therefore, we need to make sure that the table has been created before calling
-                        // prepare. As we don't want to trash whatever database this is connected to, we
-                        // create a new in-memory DB to test.
-
-                        let temp_connection = Connection::open_memory(None);
-                        //This should always succeed, if it doesn't then you really should know about it
-                        temp_connection
-                            .exec(&format!("CREATE TABLE {table_to_alter}({column})"))
-                            .unwrap()()
-                        .unwrap();
-
-                        sqlite3_prepare_v2(
-                            temp_connection.sqlite3,
-                            remaining_sql.as_ptr(),
-                            -1,
-                            &mut raw_statement,
-                            &mut remaining_sql_ptr,
-                        );
-
-                        #[cfg(not(any(target_os = "linux", target_os = "freebsd")))]
-                        let offset = sqlite3_error_offset(temp_connection.sqlite3);
-
-                        #[cfg(any(target_os = "linux", target_os = "freebsd"))]
-                        let offset = 0;
-
-                        (
-                            sqlite3_errcode(temp_connection.sqlite3),
-                            offset,
-                            sqlite3_errmsg(temp_connection.sqlite3),
-                            Some(temp_connection),
-                        )
-                    } else {
-                        sqlite3_prepare_v2(
-                            self.sqlite3,
-                            remaining_sql.as_ptr(),
-                            -1,
-                            &mut raw_statement,
-                            &mut remaining_sql_ptr,
-                        );
-
-                        #[cfg(not(any(target_os = "linux", target_os = "freebsd")))]
-                        let offset = sqlite3_error_offset(self.sqlite3);
-
-                        #[cfg(any(target_os = "linux", target_os = "freebsd"))]
-                        let offset = 0;
-
-                        (
-                            sqlite3_errcode(self.sqlite3),
-                            offset,
-                            sqlite3_errmsg(self.sqlite3),
-                            None,
-                        )
-                    };
-
-                sqlite3_finalize(raw_statement);
-
-                if res == 1 && offset >= 0 {
-                    let sub_statement_correction =
-                        remaining_sql.as_ptr() as usize - sql_start as usize;
-                    let err_msg =
-                        String::from_utf8_lossy(CStr::from_ptr(message as *const _).to_bytes())
-                            .into_owned();
-
-                    return Some((err_msg, offset as usize + sub_statement_correction));
+            } else {
+                unsafe {
+                    sqlite3_prepare_v2(
+                        self.sqlite3,
+                        remaining_sql.as_ptr(),
+                        -1,
+                        &mut raw_statement,
+                        &mut remaining_sql_ptr,
+                    )
+                };
+
+                #[cfg(not(any(target_os = "linux", target_os = "freebsd")))]
+                let offset = unsafe { sqlite3_error_offset(self.sqlite3) };
+
+                #[cfg(any(target_os = "linux", target_os = "freebsd"))]
+                let offset = 0;
+
+                unsafe {
+                    (
+                        sqlite3_errcode(self.sqlite3),
+                        offset,
+                        sqlite3_errmsg(self.sqlite3),
+                        None,
+                    )
                 }
-                remaining_sql = CStr::from_ptr(remaining_sql_ptr);
-                alter_table = None;
+            };
+
+            unsafe { sqlite3_finalize(raw_statement) };
+
+            if res == 1 && offset >= 0 {
+                let sub_statement_correction = remaining_sql.as_ptr() as usize - sql_start as usize;
+                let err_msg = String::from_utf8_lossy(unsafe {
+                    CStr::from_ptr(message as *const _).to_bytes()
+                })
+                .into_owned();
+
+                return Some((err_msg, offset as usize + sub_statement_correction));
             }
+            remaining_sql = unsafe { CStr::from_ptr(remaining_sql_ptr) };
+            alter_table = None;
         }
         None
     }
diff --git a/crates/sqlez/src/migrations.rs b/crates/sqlez/src/migrations.rs
index 2429ddeb4127591b56fb74a9c84884d9dc5f378f..567d82f9afe22ea4ab126c0989891c5d603879fd 100644
--- a/crates/sqlez/src/migrations.rs
+++ b/crates/sqlez/src/migrations.rs
@@ -59,6 +59,7 @@ impl Connection {
             let mut store_completed_migration = self
                 .exec_bound("INSERT INTO migrations (domain, step, migration) VALUES (?, ?, ?)")?;
 
+            let mut did_migrate = false;
             for (index, migration) in migrations.iter().enumerate() {
                 let migration =
                     sqlformat::format(migration, &sqlformat::QueryParams::None, Default::default());
@@ -70,9 +71,7 @@ impl Connection {
                         &sqlformat::QueryParams::None,
                         Default::default(),
                     );
-                    if completed_migration == migration
-                        || migration.trim().starts_with("-- ALLOW_MIGRATION_CHANGE")
-                    {
+                    if completed_migration == migration {
                         // Migration already run. Continue
                         continue;
                     } else if should_allow_migration_change(index, &completed_migration, &migration)
@@ -91,12 +90,58 @@ impl Connection {
                 }
 
                 self.eager_exec(&migration)?;
+                did_migrate = true;
                 store_completed_migration((domain, index, migration))?;
             }
 
+            if did_migrate {
+                self.delete_rows_with_orphaned_foreign_key_references()?;
+                self.exec("PRAGMA foreign_key_check;")?()?;
+            }
+
             Ok(())
         })
     }
+
+    /// Delete any rows that were orphaned by a migration. This is needed
+    /// because we disable foreign key constraints during migrations, so
+    /// that it's possible to re-create a table with the same name, without
+    /// deleting all associated data.
+    fn delete_rows_with_orphaned_foreign_key_references(&self) -> Result<()> {
+        let foreign_key_info: Vec<(String, String, String, String)> = self.select(
+            r#"
+                SELECT DISTINCT
+                    schema.name as child_table,
+                    foreign_keys.[from] as child_key,
+                    foreign_keys.[table] as parent_table,
+                    foreign_keys.[to] as parent_key
+                FROM sqlite_schema schema
+                JOIN pragma_foreign_key_list(schema.name) foreign_keys
+                WHERE
+                    schema.type = 'table' AND
+                    schema.name NOT LIKE "sqlite_%"
+            "#,
+        )?()?;
+
+        if !foreign_key_info.is_empty() {
+            log::info!(
+                "Found {} foreign key relationships to check",
+                foreign_key_info.len()
+            );
+        }
+
+        for (child_table, child_key, parent_table, parent_key) in foreign_key_info {
+            self.exec(&format!(
+                "
+                DELETE FROM {child_table}
+                WHERE {child_key} IS NOT NULL and {child_key} NOT IN
+                (SELECT {parent_key} FROM {parent_table})
+                "
+            ))?()?;
+        }
+
+        Ok(())
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/sqlez/src/statement.rs b/crates/sqlez/src/statement.rs
index eb7553f862b0a291bf08345606ff22317d3eec60..d08e58a6f93344d4bb52c35c8c76406724a230b4 100644
--- a/crates/sqlez/src/statement.rs
+++ b/crates/sqlez/src/statement.rs
@@ -44,41 +44,41 @@ impl<'a> Statement<'a> {
             connection,
             phantom: PhantomData,
         };
-        unsafe {
-            let sql = CString::new(query.as_ref()).context("Error creating cstr")?;
-            let mut remaining_sql = sql.as_c_str();
-            while {
-                let remaining_sql_str = remaining_sql
-                    .to_str()
-                    .context("Parsing remaining sql")?
-                    .trim();
-                remaining_sql_str != ";" && !remaining_sql_str.is_empty()
-            } {
-                let mut raw_statement = ptr::null_mut::<sqlite3_stmt>();
-                let mut remaining_sql_ptr = ptr::null();
+        let sql = CString::new(query.as_ref()).context("Error creating cstr")?;
+        let mut remaining_sql = sql.as_c_str();
+        while {
+            let remaining_sql_str = remaining_sql
+                .to_str()
+                .context("Parsing remaining sql")?
+                .trim();
+            remaining_sql_str != ";" && !remaining_sql_str.is_empty()
+        } {
+            let mut raw_statement = ptr::null_mut::<sqlite3_stmt>();
+            let mut remaining_sql_ptr = ptr::null();
+            unsafe {
                 sqlite3_prepare_v2(
                     connection.sqlite3,
                     remaining_sql.as_ptr(),
                     -1,
                     &mut raw_statement,
                     &mut remaining_sql_ptr,
-                );
+                )
+            };
 
-                connection.last_error().with_context(|| {
-                    format!("Prepare call failed for query:\n{}", query.as_ref())
-                })?;
+            connection
+                .last_error()
+                .with_context(|| format!("Prepare call failed for query:\n{}", query.as_ref()))?;
 
-                remaining_sql = CStr::from_ptr(remaining_sql_ptr);
-                statement.raw_statements.push(raw_statement);
+            remaining_sql = unsafe { CStr::from_ptr(remaining_sql_ptr) };
+            statement.raw_statements.push(raw_statement);
 
-                if !connection.can_write() && sqlite3_stmt_readonly(raw_statement) == 0 {
-                    let sql = CStr::from_ptr(sqlite3_sql(raw_statement));
+            if !connection.can_write() && unsafe { sqlite3_stmt_readonly(raw_statement) == 0 } {
+                let sql = unsafe { CStr::from_ptr(sqlite3_sql(raw_statement)) };
 
-                    bail!(
-                        "Write statement prepared with connection that is not write capable. SQL:\n{} ",
-                        sql.to_str()?
-                    )
-                }
+                bail!(
+                    "Write statement prepared with connection that is not write capable. SQL:\n{} ",
+                    sql.to_str()?
+                )
             }
         }
 
@@ -271,23 +271,21 @@ impl<'a> Statement<'a> {
     }
 
     fn step(&mut self) -> Result<StepResult> {
-        unsafe {
-            match sqlite3_step(self.current_statement()) {
-                SQLITE_ROW => Ok(StepResult::Row),
-                SQLITE_DONE => {
-                    if self.current_statement >= self.raw_statements.len() - 1 {
-                        Ok(StepResult::Done)
-                    } else {
-                        self.current_statement += 1;
-                        self.step()
-                    }
-                }
-                SQLITE_MISUSE => anyhow::bail!("Statement step returned SQLITE_MISUSE"),
-                _other_error => {
-                    self.connection.last_error()?;
-                    unreachable!("Step returned error code and last error failed to catch it");
+        match unsafe { sqlite3_step(self.current_statement()) } {
+            SQLITE_ROW => Ok(StepResult::Row),
+            SQLITE_DONE => {
+                if self.current_statement >= self.raw_statements.len() - 1 {
+                    Ok(StepResult::Done)
+                } else {
+                    self.current_statement += 1;
+                    self.step()
                 }
             }
+            SQLITE_MISUSE => anyhow::bail!("Statement step returned SQLITE_MISUSE"),
+            _other_error => {
+                self.connection.last_error()?;
+                unreachable!("Step returned error code and last error failed to catch it");
+            }
         }
     }
 
diff --git a/crates/sqlez/src/thread_safe_connection.rs b/crates/sqlez/src/thread_safe_connection.rs
index 58d3afe78fb4d8b211c48c0ae1f9f72af74ad5c1..482905ac817bf94fcb64cb858b784c94283b686c 100644
--- a/crates/sqlez/src/thread_safe_connection.rs
+++ b/crates/sqlez/src/thread_safe_connection.rs
@@ -95,6 +95,14 @@ impl<M: Migrator> ThreadSafeConnectionBuilder<M> {
                 let mut migration_result =
                     anyhow::Result::<()>::Err(anyhow::anyhow!("Migration never run"));
 
+                let foreign_keys_enabled: bool =
+                    connection.select_row::<i32>("PRAGMA foreign_keys")?()
+                        .unwrap_or(None)
+                        .map(|enabled| enabled != 0)
+                        .unwrap_or(false);
+
+                connection.exec("PRAGMA foreign_keys = OFF;")?()?;
+
                 for _ in 0..MIGRATION_RETRIES {
                     migration_result = connection
                         .with_savepoint("thread_safe_multi_migration", || M::migrate(connection));
@@ -104,6 +112,9 @@ impl<M: Migrator> ThreadSafeConnectionBuilder<M> {
                     }
                 }
 
+                if foreign_keys_enabled {
+                    connection.exec("PRAGMA foreign_keys = ON;")?()?;
+                }
                 migration_result
             })
             .await?;
diff --git a/crates/streaming_diff/src/streaming_diff.rs b/crates/streaming_diff/src/streaming_diff.rs
index 704164e01eedc64cac9a1e8e4e82f584a0b4fdb9..5677981b0dc9878963e01d09e7281749d6603c8f 100644
--- a/crates/streaming_diff/src/streaming_diff.rs
+++ b/crates/streaming_diff/src/streaming_diff.rs
@@ -945,7 +945,7 @@ mod tests {
         let mut new_len = 0;
 
         while new_len < new.len() {
-            let mut chunk_len = rng.gen_range(1..=new.len() - new_len);
+            let mut chunk_len = rng.random_range(1..=new.len() - new_len);
             while !new.is_char_boundary(new_len + chunk_len) {
                 chunk_len += 1;
             }
@@ -1034,14 +1034,14 @@ mod tests {
 
     fn randomly_edit(text: &str, rng: &mut impl Rng) -> String {
         let mut result = String::from(text);
-        let edit_count = rng.gen_range(1..=5);
+        let edit_count = rng.random_range(1..=5);
 
         fn random_char_range(text: &str, rng: &mut impl Rng) -> (usize, usize) {
-            let mut start = rng.gen_range(0..=text.len());
+            let mut start = rng.random_range(0..=text.len());
             while !text.is_char_boundary(start) {
                 start -= 1;
             }
-            let mut end = rng.gen_range(start..=text.len());
+            let mut end = rng.random_range(start..=text.len());
             while !text.is_char_boundary(end) {
                 end += 1;
             }
@@ -1049,11 +1049,11 @@ mod tests {
         }
 
         for _ in 0..edit_count {
-            match rng.gen_range(0..3) {
+            match rng.random_range(0..3) {
                 0 => {
                     // Insert
                     let (pos, _) = random_char_range(&result, rng);
-                    let insert_len = rng.gen_range(1..=5);
+                    let insert_len = rng.random_range(1..=5);
                     let insert_text: String = random_text(rng, insert_len);
                     result.insert_str(pos, &insert_text);
                 }
diff --git a/crates/sum_tree/src/sum_tree.rs b/crates/sum_tree/src/sum_tree.rs
index 710fdd4fbf12ccc2b60998207d964bd31550b345..64814ad09148cc0eb318c306132f2e296fcb3cab 100644
--- a/crates/sum_tree/src/sum_tree.rs
+++ b/crates/sum_tree/src/sum_tree.rs
@@ -909,7 +909,7 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use rand::{distributions, prelude::*};
+    use rand::{distr::StandardUniform, prelude::*};
     use std::cmp;
 
     #[ctor::ctor]
@@ -951,24 +951,24 @@ mod tests {
 
             let rng = &mut rng;
             let mut tree = SumTree::<u8>::default();
-            let count = rng.gen_range(0..10);
-            if rng.r#gen() {
-                tree.extend(rng.sample_iter(distributions::Standard).take(count), &());
+            let count = rng.random_range(0..10);
+            if rng.random() {
+                tree.extend(rng.sample_iter(StandardUniform).take(count), &());
             } else {
                 let items = rng
-                    .sample_iter(distributions::Standard)
+                    .sample_iter(StandardUniform)
                     .take(count)
                     .collect::<Vec<_>>();
                 tree.par_extend(items, &());
             }
 
             for _ in 0..num_operations {
-                let splice_end = rng.gen_range(0..tree.extent::<Count>(&()).0 + 1);
-                let splice_start = rng.gen_range(0..splice_end + 1);
-                let count = rng.gen_range(0..10);
+                let splice_end = rng.random_range(0..tree.extent::<Count>(&()).0 + 1);
+                let splice_start = rng.random_range(0..splice_end + 1);
+                let count = rng.random_range(0..10);
                 let tree_end = tree.extent::<Count>(&());
                 let new_items = rng
-                    .sample_iter(distributions::Standard)
+                    .sample_iter(StandardUniform)
                     .take(count)
                     .collect::<Vec<u8>>();
 
@@ -978,7 +978,7 @@ mod tests {
                 tree = {
                     let mut cursor = tree.cursor::<Count>(&());
                     let mut new_tree = cursor.slice(&Count(splice_start), Bias::Right);
-                    if rng.r#gen() {
+                    if rng.random() {
                         new_tree.extend(new_items, &());
                     } else {
                         new_tree.par_extend(new_items, &());
@@ -1005,7 +1005,7 @@ mod tests {
                     .filter(|(_, item)| (item & 1) == 0)
                     .collect::<Vec<_>>();
 
-                let mut item_ix = if rng.r#gen() {
+                let mut item_ix = if rng.random() {
                     filter_cursor.next();
                     0
                 } else {
@@ -1022,12 +1022,12 @@ mod tests {
                     filter_cursor.next();
                     item_ix += 1;
 
-                    while item_ix > 0 && rng.gen_bool(0.2) {
+                    while item_ix > 0 && rng.random_bool(0.2) {
                         log::info!("prev");
                         filter_cursor.prev();
                         item_ix -= 1;
 
-                        if item_ix == 0 && rng.gen_bool(0.2) {
+                        if item_ix == 0 && rng.random_bool(0.2) {
                             filter_cursor.prev();
                             assert_eq!(filter_cursor.item(), None);
                             assert_eq!(filter_cursor.start().0, 0);
@@ -1039,9 +1039,9 @@ mod tests {
 
                 let mut before_start = false;
                 let mut cursor = tree.cursor::<Count>(&());
-                let start_pos = rng.gen_range(0..=reference_items.len());
+                let start_pos = rng.random_range(0..=reference_items.len());
                 cursor.seek(&Count(start_pos), Bias::Right);
-                let mut pos = rng.gen_range(start_pos..=reference_items.len());
+                let mut pos = rng.random_range(start_pos..=reference_items.len());
                 cursor.seek_forward(&Count(pos), Bias::Right);
 
                 for i in 0..10 {
@@ -1084,10 +1084,18 @@ mod tests {
             }
 
             for _ in 0..10 {
-                let end = rng.gen_range(0..tree.extent::<Count>(&()).0 + 1);
-                let start = rng.gen_range(0..end + 1);
-                let start_bias = if rng.r#gen() { Bias::Left } else { Bias::Right };
-                let end_bias = if rng.r#gen() { Bias::Left } else { Bias::Right };
+                let end = rng.random_range(0..tree.extent::<Count>(&()).0 + 1);
+                let start = rng.random_range(0..end + 1);
+                let start_bias = if rng.random() {
+                    Bias::Left
+                } else {
+                    Bias::Right
+                };
+                let end_bias = if rng.random() {
+                    Bias::Left
+                } else {
+                    Bias::Right
+                };
 
                 let mut cursor = tree.cursor::<Count>(&());
                 cursor.seek(&Count(start), start_bias);
diff --git a/crates/task/src/task_template.rs b/crates/task/src/task_template.rs
index 3d1d180557fc457e4200a5b246f2a08e2f5dfcf0..a57f5a175af3fd79ce6b8ef818e3fb97acdc32c2 100644
--- a/crates/task/src/task_template.rs
+++ b/crates/task/src/task_template.rs
@@ -333,15 +333,16 @@ fn substitute_all_template_variables_in_str<A: AsRef<str>>(
             if let Some(substituted_variable) = variable_names.get(variable_name) {
                 substituted_variables.insert(substituted_variable.clone());
             }
-
-            let mut name = name.as_ref().to_owned();
-            // Got a task variable hit
+            // Got a task variable hit - use the variable value, ignore default
+            return Ok(Some(name.as_ref().to_owned()));
+        } else if variable_name.starts_with(ZED_VARIABLE_NAME_PREFIX) {
+            // Unknown ZED variable - use default if available
             if !default.is_empty() {
-                name.push_str(default);
+                // Strip the colon and return the default value
+                return Ok(Some(default[1..].to_owned()));
+            } else {
+                bail!("Unknown variable name: {variable_name}");
             }
-            return Ok(Some(name));
-        } else if variable_name.starts_with(ZED_VARIABLE_NAME_PREFIX) {
-            bail!("Unknown variable name: {variable_name}");
         }
         // This is an unknown variable.
         // We should not error out, as they may come from user environment (e.g. $PATH). That means that the variable substitution might not be perfect.
@@ -892,4 +893,81 @@ mod tests {
             "overwritten"
         );
     }
+
+    #[test]
+    fn test_variable_default_values() {
+        let task_with_defaults = TaskTemplate {
+            label: "test with defaults".to_string(),
+            command: format!(
+                "echo ${{{}}}",
+                VariableName::File.to_string() + ":fallback.txt"
+            ),
+            args: vec![
+                "${ZED_MISSING_VAR:default_value}".to_string(),
+                format!("${{{}}}", VariableName::Row.to_string() + ":42"),
+            ],
+            ..TaskTemplate::default()
+        };
+
+        // Test 1: When ZED_FILE exists, should use actual value and ignore default
+        let context_with_file = TaskContext {
+            cwd: None,
+            task_variables: TaskVariables::from_iter(vec![
+                (VariableName::File, "actual_file.rs".to_string()),
+                (VariableName::Row, "123".to_string()),
+            ]),
+            project_env: HashMap::default(),
+        };
+
+        let resolved = task_with_defaults
+            .resolve_task(TEST_ID_BASE, &context_with_file)
+            .expect("Should resolve task with existing variables");
+
+        assert_eq!(
+            resolved.resolved.command.unwrap(),
+            "echo actual_file.rs",
+            "Should use actual ZED_FILE value, not default"
+        );
+        assert_eq!(
+            resolved.resolved.args,
+            vec!["default_value", "123"],
+            "Should use default for missing var, actual value for existing var"
+        );
+
+        // Test 2: When ZED_FILE doesn't exist, should use default value
+        let context_without_file = TaskContext {
+            cwd: None,
+            task_variables: TaskVariables::from_iter(vec![(VariableName::Row, "456".to_string())]),
+            project_env: HashMap::default(),
+        };
+
+        let resolved = task_with_defaults
+            .resolve_task(TEST_ID_BASE, &context_without_file)
+            .expect("Should resolve task using default values");
+
+        assert_eq!(
+            resolved.resolved.command.unwrap(),
+            "echo fallback.txt",
+            "Should use default value when ZED_FILE is missing"
+        );
+        assert_eq!(
+            resolved.resolved.args,
+            vec!["default_value", "456"],
+            "Should use defaults for missing vars"
+        );
+
+        // Test 3: Missing ZED variable without default should fail
+        let task_no_default = TaskTemplate {
+            label: "test no default".to_string(),
+            command: "${ZED_MISSING_NO_DEFAULT}".to_string(),
+            ..TaskTemplate::default()
+        };
+
+        assert!(
+            task_no_default
+                .resolve_task(TEST_ID_BASE, &TaskContext::default())
+                .is_none(),
+            "Should fail when ZED variable has no default and doesn't exist"
+        );
+    }
 }
diff --git a/crates/terminal/src/terminal.rs b/crates/terminal/src/terminal.rs
index a8b1fcf0f2a31cbd80612d2e19506d38d52fe0af..96271ea771e3fdbe42b03504797ba78170d79096 100644
--- a/crates/terminal/src/terminal.rs
+++ b/crates/terminal/src/terminal.rs
@@ -2198,7 +2198,7 @@ mod tests {
     };
     use collections::HashMap;
     use gpui::{Pixels, Point, TestAppContext, bounds, point, size};
-    use rand::{Rng, distributions::Alphanumeric, rngs::ThreadRng, thread_rng};
+    use rand::{Rng, distr, rngs::ThreadRng};
 
     #[ignore = "Test is flaky on macOS, and doesn't run on Windows"]
     #[gpui::test]
@@ -2249,13 +2249,14 @@ mod tests {
 
     #[test]
     fn test_mouse_to_cell_test() {
-        let mut rng = thread_rng();
+        let mut rng = rand::rng();
         const ITERATIONS: usize = 10;
         const PRECISION: usize = 1000;
 
         for _ in 0..ITERATIONS {
-            let viewport_cells = rng.gen_range(15..20);
-            let cell_size = rng.gen_range(5 * PRECISION..20 * PRECISION) as f32 / PRECISION as f32;
+            let viewport_cells = rng.random_range(15..20);
+            let cell_size =
+                rng.random_range(5 * PRECISION..20 * PRECISION) as f32 / PRECISION as f32;
 
             let size = crate::TerminalBounds {
                 cell_width: Pixels::from(cell_size),
@@ -2277,8 +2278,8 @@ mod tests {
                 for col in 0..(viewport_cells - 1) {
                     let col = col as usize;
 
-                    let row_offset = rng.gen_range(0..PRECISION) as f32 / PRECISION as f32;
-                    let col_offset = rng.gen_range(0..PRECISION) as f32 / PRECISION as f32;
+                    let row_offset = rng.random_range(0..PRECISION) as f32 / PRECISION as f32;
+                    let col_offset = rng.random_range(0..PRECISION) as f32 / PRECISION as f32;
 
                     let mouse_pos = point(
                         Pixels::from(col as f32 * cell_size + col_offset),
@@ -2298,7 +2299,7 @@ mod tests {
 
     #[test]
     fn test_mouse_to_cell_clamp() {
-        let mut rng = thread_rng();
+        let mut rng = rand::rng();
 
         let size = crate::TerminalBounds {
             cell_width: Pixels::from(10.),
@@ -2336,7 +2337,7 @@ mod tests {
         for _ in 0..((size.height() / size.line_height()) as usize) {
             let mut row_vec = Vec::new();
             for _ in 0..((size.width() / size.cell_width()) as usize) {
-                let cell_char = rng.sample(Alphanumeric) as char;
+                let cell_char = rng.sample(distr::Alphanumeric) as char;
                 row_vec.push(cell_char)
             }
             cells.push(row_vec)
diff --git a/crates/terminal/src/terminal_hyperlinks.rs b/crates/terminal/src/terminal_hyperlinks.rs
index 9f565bd306a49ad49e0df58315950838d6446eac..4126b3d948072e8d8d24b84fce4574fba889e492 100644
--- a/crates/terminal/src/terminal_hyperlinks.rs
+++ b/crates/terminal/src/terminal_hyperlinks.rs
@@ -1,1221 +1,1221 @@
-use alacritty_terminal::{
-    Term,
-    event::EventListener,
-    grid::Dimensions,
-    index::{Boundary, Column, Direction as AlacDirection, Line, Point as AlacPoint},
-    term::search::{Match, RegexIter, RegexSearch},
-};
-use regex::Regex;
-use std::{ops::Index, sync::LazyLock};
-
-const URL_REGEX: &str = r#"(ipfs:|ipns:|magnet:|mailto:|gemini://|gopher://|https://|http://|news:|file://|git://|ssh:|ftp://)[^\u{0000}-\u{001F}\u{007F}-\u{009F}<>"\s{-}\^⟨⟩`']+"#;
-// Optional suffix matches MSBuild diagnostic suffixes for path parsing in PathLikeWithPosition
-// https://learn.microsoft.com/en-us/visualstudio/msbuild/msbuild-diagnostic-format-for-tasks
-const WORD_REGEX: &str =
-    r#"[\$\+\w.\[\]:/\\@\-~()]+(?:\((?:\d+|\d+,\d+)\))|[\$\+\w.\[\]:/\\@\-~()]+"#;
-
-const PYTHON_FILE_LINE_REGEX: &str = r#"File "(?P<file>[^"]+)", line (?P<line>\d+)"#;
-
-static PYTHON_FILE_LINE_MATCHER: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(PYTHON_FILE_LINE_REGEX).unwrap());
-
-fn python_extract_path_and_line(input: &str) -> Option<(&str, u32)> {
-    if let Some(captures) = PYTHON_FILE_LINE_MATCHER.captures(input) {
-        let path_part = captures.name("file")?.as_str();
-
-        let line_number: u32 = captures.name("line")?.as_str().parse().ok()?;
-        return Some((path_part, line_number));
-    }
-    None
-}
-
-pub(super) struct RegexSearches {
-    url_regex: RegexSearch,
-    word_regex: RegexSearch,
-    python_file_line_regex: RegexSearch,
-}
-
-impl RegexSearches {
-    pub(super) fn new() -> Self {
-        Self {
-            url_regex: RegexSearch::new(URL_REGEX).unwrap(),
-            word_regex: RegexSearch::new(WORD_REGEX).unwrap(),
-            python_file_line_regex: RegexSearch::new(PYTHON_FILE_LINE_REGEX).unwrap(),
-        }
-    }
-}
-
-pub(super) fn find_from_grid_point<T: EventListener>(
-    term: &Term<T>,
-    point: AlacPoint,
-    regex_searches: &mut RegexSearches,
-) -> Option<(String, bool, Match)> {
-    let grid = term.grid();
-    let link = grid.index(point).hyperlink();
-    let found_word = if let Some(ref url) = link {
-        let mut min_index = point;
-        loop {
-            let new_min_index = min_index.sub(term, Boundary::Cursor, 1);
-            if new_min_index == min_index || grid.index(new_min_index).hyperlink() != link {
-                break;
-            } else {
-                min_index = new_min_index
-            }
-        }
-
-        let mut max_index = point;
-        loop {
-            let new_max_index = max_index.add(term, Boundary::Cursor, 1);
-            if new_max_index == max_index || grid.index(new_max_index).hyperlink() != link {
-                break;
-            } else {
-                max_index = new_max_index
-            }
-        }
-
-        let url = url.uri().to_owned();
-        let url_match = min_index..=max_index;
-
-        Some((url, true, url_match))
-    } else if let Some(url_match) = regex_match_at(term, point, &mut regex_searches.url_regex) {
-        let url = term.bounds_to_string(*url_match.start(), *url_match.end());
-        Some((url, true, url_match))
-    } else if let Some(python_match) =
-        regex_match_at(term, point, &mut regex_searches.python_file_line_regex)
-    {
-        let matching_line = term.bounds_to_string(*python_match.start(), *python_match.end());
-        python_extract_path_and_line(&matching_line).map(|(file_path, line_number)| {
-            (format!("{file_path}:{line_number}"), false, python_match)
-        })
-    } else if let Some(word_match) = regex_match_at(term, point, &mut regex_searches.word_regex) {
-        let file_path = term.bounds_to_string(*word_match.start(), *word_match.end());
-
-        let (sanitized_match, sanitized_word) = 'sanitize: {
-            let mut word_match = word_match;
-            let mut file_path = file_path;
-
-            if is_path_surrounded_by_common_symbols(&file_path) {
-                word_match = Match::new(
-                    word_match.start().add(term, Boundary::Grid, 1),
-                    word_match.end().sub(term, Boundary::Grid, 1),
-                );
-                file_path = file_path[1..file_path.len() - 1].to_owned();
-            }
-
-            while file_path.ends_with(':') {
-                file_path.pop();
-                word_match = Match::new(
-                    *word_match.start(),
-                    word_match.end().sub(term, Boundary::Grid, 1),
-                );
-            }
-            let mut colon_count = 0;
-            for c in file_path.chars() {
-                if c == ':' {
-                    colon_count += 1;
-                }
-            }
-            // strip trailing comment after colon in case of
-            // file/at/path.rs:row:column:description or error message
-            // so that the file path is `file/at/path.rs:row:column`
-            if colon_count > 2 {
-                let last_index = file_path.rfind(':').unwrap();
-                let prev_is_digit = last_index > 0
-                    && file_path
-                        .chars()
-                        .nth(last_index - 1)
-                        .is_some_and(|c| c.is_ascii_digit());
-                let next_is_digit = last_index < file_path.len() - 1
-                    && file_path
-                        .chars()
-                        .nth(last_index + 1)
-                        .is_none_or(|c| c.is_ascii_digit());
-                if prev_is_digit && !next_is_digit {
-                    let stripped_len = file_path.len() - last_index;
-                    word_match = Match::new(
-                        *word_match.start(),
-                        word_match.end().sub(term, Boundary::Grid, stripped_len),
-                    );
-                    file_path = file_path[0..last_index].to_owned();
-                }
-            }
-
-            break 'sanitize (word_match, file_path);
-        };
-
-        Some((sanitized_word, false, sanitized_match))
-    } else {
-        None
-    };
-
-    found_word.map(|(maybe_url_or_path, is_url, word_match)| {
-        if is_url {
-            // Treat "file://" IRIs like file paths to ensure
-            // that line numbers at the end of the path are
-            // handled correctly
-            if let Some(path) = maybe_url_or_path.strip_prefix("file://") {
-                (path.to_string(), false, word_match)
-            } else {
-                (maybe_url_or_path, true, word_match)
-            }
-        } else {
-            (maybe_url_or_path, false, word_match)
-        }
-    })
-}
-
-fn is_path_surrounded_by_common_symbols(path: &str) -> bool {
-    // Avoid detecting `[]` or `()` strings as paths, surrounded by common symbols
-    path.len() > 2
-        // The rest of the brackets and various quotes cannot be matched by the [`WORD_REGEX`] hence not checked for.
-        && (path.starts_with('[') && path.ends_with(']')
-            || path.starts_with('(') && path.ends_with(')'))
-}
-
-/// Based on alacritty/src/display/hint.rs > regex_match_at
-/// Retrieve the match, if the specified point is inside the content matching the regex.
-fn regex_match_at<T>(term: &Term<T>, point: AlacPoint, regex: &mut RegexSearch) -> Option<Match> {
-    visible_regex_match_iter(term, regex).find(|rm| rm.contains(&point))
-}
-
-/// Copied from alacritty/src/display/hint.rs:
-/// Iterate over all visible regex matches.
-fn visible_regex_match_iter<'a, T>(
-    term: &'a Term<T>,
-    regex: &'a mut RegexSearch,
-) -> impl Iterator<Item = Match> + 'a {
-    const MAX_SEARCH_LINES: usize = 100;
-
-    let viewport_start = Line(-(term.grid().display_offset() as i32));
-    let viewport_end = viewport_start + term.bottommost_line();
-    let mut start = term.line_search_left(AlacPoint::new(viewport_start, Column(0)));
-    let mut end = term.line_search_right(AlacPoint::new(viewport_end, Column(0)));
-    start.line = start.line.max(viewport_start - MAX_SEARCH_LINES);
-    end.line = end.line.min(viewport_end + MAX_SEARCH_LINES);
-
-    RegexIter::new(start, end, AlacDirection::Right, term, regex)
-        .skip_while(move |rm| rm.end().line < viewport_start)
-        .take_while(move |rm| rm.start().line <= viewport_end)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use alacritty_terminal::{
-        event::VoidListener,
-        index::{Boundary, Point as AlacPoint},
-        term::{Config, cell::Flags, test::TermSize},
-        vte::ansi::Handler,
-    };
-    use std::{cell::RefCell, ops::RangeInclusive, path::PathBuf};
-    use url::Url;
-    use util::paths::PathWithPosition;
-
-    fn re_test(re: &str, hay: &str, expected: Vec<&str>) {
-        let results: Vec<_> = regex::Regex::new(re)
-            .unwrap()
-            .find_iter(hay)
-            .map(|m| m.as_str())
-            .collect();
-        assert_eq!(results, expected);
-    }
-
-    #[test]
-    fn test_url_regex() {
-        re_test(
-            URL_REGEX,
-            "test http://example.com test 'https://website1.com' test mailto:bob@example.com train",
-            vec![
-                "http://example.com",
-                "https://website1.com",
-                "mailto:bob@example.com",
-            ],
-        );
-    }
-
-    #[test]
-    fn test_word_regex() {
-        re_test(
-            WORD_REGEX,
-            "hello, world! \"What\" is this?",
-            vec!["hello", "world", "What", "is", "this"],
-        );
-    }
-
-    #[test]
-    fn test_word_regex_with_linenum() {
-        // filename(line) and filename(line,col) as used in MSBuild output
-        // should be considered a single "word", even though comma is
-        // usually a word separator
-        re_test(WORD_REGEX, "a Main.cs(20) b", vec!["a", "Main.cs(20)", "b"]);
-        re_test(
-            WORD_REGEX,
-            "Main.cs(20,5) Error desc",
-            vec!["Main.cs(20,5)", "Error", "desc"],
-        );
-        // filename:line:col is a popular format for unix tools
-        re_test(
-            WORD_REGEX,
-            "a Main.cs:20:5 b",
-            vec!["a", "Main.cs:20:5", "b"],
-        );
-        // Some tools output "filename:line:col:message", which currently isn't
-        // handled correctly, but might be in the future
-        re_test(
-            WORD_REGEX,
-            "Main.cs:20:5:Error desc",
-            vec!["Main.cs:20:5:Error", "desc"],
-        );
-    }
-
-    #[test]
-    fn test_python_file_line_regex() {
-        re_test(
-            PYTHON_FILE_LINE_REGEX,
-            "hay File \"/zed/bad_py.py\", line 8 stack",
-            vec!["File \"/zed/bad_py.py\", line 8"],
-        );
-        re_test(PYTHON_FILE_LINE_REGEX, "unrelated", vec![]);
-    }
-
-    #[test]
-    fn test_python_file_line() {
-        let inputs: Vec<(&str, Option<(&str, u32)>)> = vec![
-            (
-                "File \"/zed/bad_py.py\", line 8",
-                Some(("/zed/bad_py.py", 8u32)),
-            ),
-            ("File \"path/to/zed/bad_py.py\"", None),
-            ("unrelated", None),
-            ("", None),
-        ];
-        let actual = inputs
-            .iter()
-            .map(|input| python_extract_path_and_line(input.0))
-            .collect::<Vec<_>>();
-        let expected = inputs.iter().map(|(_, output)| *output).collect::<Vec<_>>();
-        assert_eq!(actual, expected);
-    }
-
-    // We use custom columns in many tests to workaround this issue by ensuring a wrapped
-    // line never ends on a wide char:
-    //
-    // <https://github.com/alacritty/alacritty/issues/8586>
-    //
-    // This issue was recently fixed, as soon as we update to a version containing the fix we
-    // can remove all the custom columns from these tests.
-    //
-    macro_rules! test_hyperlink {
-        ($($lines:expr),+; $hyperlink_kind:ident) => { {
-            use crate::terminal_hyperlinks::tests::line_cells_count;
-            use std::cmp;
-
-            let test_lines = vec![$($lines),+];
-            let (total_cells, longest_line_cells) =
-                test_lines.iter().copied()
-                    .map(line_cells_count)
-                    .fold((0, 0), |state, cells| (state.0 + cells, cmp::max(state.1, cells)));
-
-            test_hyperlink!(
-                // Alacritty has issues with 2 columns, use 3 as the minimum for now.
-                [3, longest_line_cells / 2, longest_line_cells + 1];
-                total_cells;
-                test_lines.iter().copied();
-                $hyperlink_kind
-            )
-        } };
-
-        ($($columns:literal),+; $($lines:expr),+; $hyperlink_kind:ident) => { {
-            use crate::terminal_hyperlinks::tests::line_cells_count;
-
-            let test_lines = vec![$($lines),+];
-            let total_cells = test_lines.iter().copied().map(line_cells_count).sum();
-
-            test_hyperlink!(
-                [ $($columns),+ ]; total_cells; test_lines.iter().copied(); $hyperlink_kind
-            )
-        } };
-
-        ([ $($columns:expr),+ ]; $total_cells:expr; $lines:expr; $hyperlink_kind:ident) => { {
-            use crate::terminal_hyperlinks::tests::{ test_hyperlink, HyperlinkKind };
-
-            let source_location = format!("{}:{}", std::file!(), std::line!());
-            for columns in vec![ $($columns),+] {
-                test_hyperlink(columns, $total_cells, $lines, HyperlinkKind::$hyperlink_kind,
-                    &source_location);
-            }
-        } };
-    }
-
-    mod path {
-        /// 👉 := **hovered** on following char
-        ///
-        /// 👈 := **hovered** on wide char spacer of previous full width char
-        ///
-        /// **`‹›`** := expected **hyperlink** match
-        ///
-        /// **`«»`** := expected **path**, **row**, and **column** capture groups
-        ///
-        /// [**`c₀, c₁, …, cₙ;`**]ₒₚₜ := use specified terminal widths of `c₀, c₁, …, cₙ` **columns**
-        /// (defaults to `3, longest_line_cells / 2, longest_line_cells + 1;`)
-        ///
-        macro_rules! test_path {
-            ($($lines:literal),+) => { test_hyperlink!($($lines),+; Path) };
-            ($($columns:literal),+; $($lines:literal),+) => {
-                test_hyperlink!($($columns),+; $($lines),+; Path)
-            };
-        }
-
-        #[test]
-        fn simple() {
-            // Rust paths
-            // Just the path
-            test_path!("‹«/👉test/cool.rs»›");
-            test_path!("‹«/test/cool👉.rs»›");
-
-            // path and line
-            test_path!("‹«/👉test/cool.rs»:«4»›");
-            test_path!("‹«/test/cool.rs»👉:«4»›");
-            test_path!("‹«/test/cool.rs»:«👉4»›");
-            test_path!("‹«/👉test/cool.rs»(«4»)›");
-            test_path!("‹«/test/cool.rs»👉(«4»)›");
-            test_path!("‹«/test/cool.rs»(«👉4»)›");
-            test_path!("‹«/test/cool.rs»(«4»👉)›");
-
-            // path, line, and column
-            test_path!("‹«/👉test/cool.rs»:«4»:«2»›");
-            test_path!("‹«/test/cool.rs»:«4»:«👉2»›");
-            test_path!("‹«/👉test/cool.rs»(«4»,«2»)›");
-            test_path!("‹«/test/cool.rs»(«4»👉,«2»)›");
-
-            // path, line, column, and ':' suffix
-            test_path!("‹«/👉test/cool.rs»:«4»:«2»›:");
-            test_path!("‹«/test/cool.rs»:«4»:«👉2»›:");
-            test_path!("‹«/👉test/cool.rs»(«4»,«2»)›:");
-            test_path!("‹«/test/cool.rs»(«4»,«2»👉)›:");
-
-            // path, line, column, and description
-            test_path!("‹«/test/cool.rs»:«4»:«2»›👉:Error!");
-            test_path!("‹«/test/cool.rs»:«4»:«2»›:👉Error!");
-            test_path!("‹«/test/co👉ol.rs»(«4»,«2»)›:Error!");
-
-            // Cargo output
-            test_path!("    Compiling Cool 👉(‹«/test/Cool»›)");
-            test_path!("    Compiling Cool (‹«/👉test/Cool»›)");
-            test_path!("    Compiling Cool (‹«/test/Cool»›👉)");
-
-            // Python
-            test_path!("‹«awe👉some.py»›");
-
-            test_path!("    ‹F👉ile \"«/awesome.py»\", line «42»›: Wat?");
-            test_path!("    ‹File \"«/awe👉some.py»\", line «42»›: Wat?");
-            test_path!("    ‹File \"«/awesome.py»👉\", line «42»›: Wat?");
-            test_path!("    ‹File \"«/awesome.py»\", line «4👉2»›: Wat?");
-        }
-
-        #[test]
-        fn colons_galore() {
-            test_path!("‹«/test/co👉ol.rs»:«4»›");
-            test_path!("‹«/test/co👉ol.rs»:«4»›:");
-            test_path!("‹«/test/co👉ol.rs»:«4»:«2»›");
-            test_path!("‹«/test/co👉ol.rs»:«4»:«2»›:");
-            test_path!("‹«/test/co👉ol.rs»(«1»)›");
-            test_path!("‹«/test/co👉ol.rs»(«1»)›:");
-            test_path!("‹«/test/co👉ol.rs»(«1»,«618»)›");
-            test_path!("‹«/test/co👉ol.rs»(«1»,«618»)›:");
-            test_path!("‹«/test/co👉ol.rs»::«42»›");
-            test_path!("‹«/test/co👉ol.rs»::«42»›:");
-            test_path!("‹«/test/co👉ol.rs:4:2»(«1»,«618»)›");
-            test_path!("‹«/test/co👉ol.rs»(«1»,«618»)›::");
-        }
-
-        #[test]
-        fn word_wide_chars() {
-            // Rust paths
-            test_path!(4, 6, 12; "‹«/👉例/cool.rs»›");
-            test_path!(4, 6, 12; "‹«/例👈/cool.rs»›");
-            test_path!(4, 8, 16; "‹«/例/cool.rs»:«👉4»›");
-            test_path!(4, 8, 16; "‹«/例/cool.rs»:«4»:«👉2»›");
-
-            // Cargo output
-            test_path!(4, 27, 30; "    Compiling Cool (‹«/👉例/Cool»›)");
-            test_path!(4, 27, 30; "    Compiling Cool (‹«/例👈/Cool»›)");
-
-            // Python
-            test_path!(4, 11; "‹«👉例wesome.py»›");
-            test_path!(4, 11; "‹«例👈wesome.py»›");
-            test_path!(6, 17, 40; "    ‹File \"«/👉例wesome.py»\", line «42»›: Wat?");
-            test_path!(6, 17, 40; "    ‹File \"«/例👈wesome.py»\", line «42»›: Wat?");
-        }
-
-        #[test]
-        fn non_word_wide_chars() {
-            // Mojo diagnostic message
-            test_path!(4, 18, 38; "    ‹File \"«/awe👉some.🔥»\", line «42»›: Wat?");
-            test_path!(4, 18, 38; "    ‹File \"«/awesome👉.🔥»\", line «42»›: Wat?");
-            test_path!(4, 18, 38; "    ‹File \"«/awesome.👉🔥»\", line «42»›: Wat?");
-            test_path!(4, 18, 38; "    ‹File \"«/awesome.🔥👈»\", line «42»›: Wat?");
-        }
-
-        /// These likely rise to the level of being worth fixing.
-        mod issues {
-            #[test]
-            #[cfg_attr(not(target_os = "windows"), should_panic(expected = "Path = «例»"))]
-            #[cfg_attr(target_os = "windows", should_panic(expected = r#"Path = «C:\\例»"#))]
-            // <https://github.com/alacritty/alacritty/issues/8586>
-            fn issue_alacritty_8586() {
-                // Rust paths
-                test_path!("‹«/👉例/cool.rs»›");
-                test_path!("‹«/例👈/cool.rs»›");
-                test_path!("‹«/例/cool.rs»:«👉4»›");
-                test_path!("‹«/例/cool.rs»:«4»:«👉2»›");
-
-                // Cargo output
-                test_path!("    Compiling Cool (‹«/👉例/Cool»›)");
-                test_path!("    Compiling Cool (‹«/例👈/Cool»›)");
-
-                // Python
-                test_path!("‹«👉例wesome.py»›");
-                test_path!("‹«例👈wesome.py»›");
-                test_path!("    ‹File \"«/👉例wesome.py»\", line «42»›: Wat?");
-                test_path!("    ‹File \"«/例👈wesome.py»\", line «42»›: Wat?");
-            }
-
-            #[test]
-            #[should_panic(expected = "No hyperlink found")]
-            // <https://github.com/zed-industries/zed/issues/12338>
-            fn issue_12338() {
-                // Issue #12338
-                test_path!(".rw-r--r--     0     staff 05-27 14:03 ‹«test👉、2.txt»›");
-                test_path!(".rw-r--r--     0     staff 05-27 14:03 ‹«test、👈2.txt»›");
-                test_path!(".rw-r--r--     0     staff 05-27 14:03 ‹«test👉。3.txt»›");
-                test_path!(".rw-r--r--     0     staff 05-27 14:03 ‹«test。👈3.txt»›");
-
-                // Rust paths
-                test_path!("‹«/👉🏃/🦀.rs»›");
-                test_path!("‹«/🏃👈/🦀.rs»›");
-                test_path!("‹«/🏃/👉🦀.rs»:«4»›");
-                test_path!("‹«/🏃/🦀👈.rs»:«4»:«2»›");
-
-                // Cargo output
-                test_path!("    Compiling Cool (‹«/👉🏃/Cool»›)");
-                test_path!("    Compiling Cool (‹«/🏃👈/Cool»›)");
-
-                // Python
-                test_path!("‹«👉🏃wesome.py»›");
-                test_path!("‹«🏃👈wesome.py»›");
-                test_path!("    ‹File \"«/👉🏃wesome.py»\", line «42»›: Wat?");
-                test_path!("    ‹File \"«/🏃👈wesome.py»\", line «42»›: Wat?");
-
-                // Mojo
-                test_path!("‹«/awe👉some.🔥»› is some good Mojo!");
-                test_path!("‹«/awesome👉.🔥»› is some good Mojo!");
-                test_path!("‹«/awesome.👉🔥»› is some good Mojo!");
-                test_path!("‹«/awesome.🔥👈»› is some good Mojo!");
-                test_path!("    ‹File \"«/👉🏃wesome.🔥»\", line «42»›: Wat?");
-                test_path!("    ‹File \"«/🏃👈wesome.🔥»\", line «42»›: Wat?");
-            }
-
-            #[test]
-            #[cfg_attr(
-                not(target_os = "windows"),
-                should_panic(
-                    expected = "Path = «test/controllers/template_items_controller_test.rb», line = 20, at grid cells (0, 0)..=(17, 1)"
-                )
-            )]
-            #[cfg_attr(
-                target_os = "windows",
-                should_panic(
-                    expected = r#"Path = «test\\controllers\\template_items_controller_test.rb», line = 20, at grid cells (0, 0)..=(17, 1)"#
-                )
-            )]
-            // <https://github.com/zed-industries/zed/issues/28194>
-            //
-            // #28194 was closed, but the link includes the description part (":in" here), which
-            // seems wrong...
-            fn issue_28194() {
-                test_path!(
-                    "‹«test/c👉ontrollers/template_items_controller_test.rb»:«20»›:in 'block (2 levels) in <class:TemplateItemsControllerTest>'"
-                );
-                test_path!(
-                    "‹«test/controllers/template_items_controller_test.rb»:«19»›:i👉n 'block in <class:TemplateItemsControllerTest>'"
-                );
-            }
-        }
-
-        /// Minor issues arguably not important enough to fix/workaround...
-        mod nits {
-            #[test]
-            #[cfg_attr(
-                not(target_os = "windows"),
-                should_panic(expected = "Path = «/test/cool.rs(4»")
-            )]
-            #[cfg_attr(
-                target_os = "windows",
-                should_panic(expected = r#"Path = «C:\\test\\cool.rs(4»"#)
-            )]
-            fn alacritty_bugs_with_two_columns() {
-                test_path!(2; "‹«/👉test/cool.rs»(«4»)›");
-                test_path!(2; "‹«/test/cool.rs»(«👉4»)›");
-                test_path!(2; "‹«/test/cool.rs»(«4»,«👉2»)›");
-
-                // Python
-                test_path!(2; "‹«awe👉some.py»›");
-            }
-
-            #[test]
-            #[cfg_attr(
-                not(target_os = "windows"),
-                should_panic(
-                    expected = "Path = «/test/cool.rs», line = 1, at grid cells (0, 0)..=(9, 0)"
-                )
-            )]
-            #[cfg_attr(
-                target_os = "windows",
-                should_panic(
-                    expected = r#"Path = «C:\\test\\cool.rs», line = 1, at grid cells (0, 0)..=(9, 2)"#
-                )
-            )]
-            fn invalid_row_column_should_be_part_of_path() {
-                test_path!("‹«/👉test/cool.rs:1:618033988749»›");
-                test_path!("‹«/👉test/cool.rs(1,618033988749)»›");
-            }
-
-            #[test]
-            #[should_panic(expected = "Path = «»")]
-            fn colon_suffix_succeeds_in_finding_an_empty_maybe_path() {
-                test_path!("‹«/test/cool.rs»:«4»:«2»›👉:", "What is this?");
-                test_path!("‹«/test/cool.rs»(«4»,«2»)›👉:", "What is this?");
-            }
-
-            #[test]
-            #[cfg_attr(
-                not(target_os = "windows"),
-                should_panic(expected = "Path = «/test/cool.rs»")
-            )]
-            #[cfg_attr(
-                target_os = "windows",
-                should_panic(expected = r#"Path = «C:\\test\\cool.rs»"#)
-            )]
-            fn many_trailing_colons_should_be_parsed_as_part_of_the_path() {
-                test_path!("‹«/test/cool.rs:::👉:»›");
-                test_path!("‹«/te:st/👉co:ol.r:s:4:2::::::»›");
-            }
-        }
-
-        #[cfg(target_os = "windows")]
-        mod windows {
-            // Lots of fun to be had with long file paths (verbatim) and UNC paths on Windows.
-            // See <https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation>
-            // See <https://users.rust-lang.org/t/understanding-windows-paths/58583>
-            // See <https://github.com/rust-lang/cargo/issues/13919>
-
-            #[test]
-            fn unc() {
-                test_path!(r#"‹«\\server\share\👉test\cool.rs»›"#);
-                test_path!(r#"‹«\\server\share\test\cool👉.rs»›"#);
-            }
-
-            mod issues {
-                #[test]
-                #[should_panic(
-                    expected = r#"Path = «C:\\test\\cool.rs», at grid cells (0, 0)..=(6, 0)"#
-                )]
-                fn issue_verbatim() {
-                    test_path!(r#"‹«\\?\C:\👉test\cool.rs»›"#);
-                    test_path!(r#"‹«\\?\C:\test\cool👉.rs»›"#);
-                }
-
-                #[test]
-                #[should_panic(
-                    expected = r#"Path = «\\\\server\\share\\test\\cool.rs», at grid cells (0, 0)..=(10, 2)"#
-                )]
-                fn issue_verbatim_unc() {
-                    test_path!(r#"‹«\\?\UNC\server\share\👉test\cool.rs»›"#);
-                    test_path!(r#"‹«\\?\UNC\server\share\test\cool👉.rs»›"#);
-                }
-            }
-        }
-    }
-
-    mod file_iri {
-        // File IRIs have a ton of use cases, most of which we currently do not support. A few of
-        // those cases are documented here as tests which are expected to fail.
-        // See https://en.wikipedia.org/wiki/File_URI_scheme
-
-        /// [**`c₀, c₁, …, cₙ;`**]ₒₚₜ := use specified terminal widths of `c₀, c₁, …, cₙ` **columns**
-        /// (defaults to `3, longest_line_cells / 2, longest_line_cells + 1;`)
-        ///
-        macro_rules! test_file_iri {
-            ($file_iri:literal) => { { test_hyperlink!(concat!("‹«👉", $file_iri, "»›"); FileIri) } };
-            ($($columns:literal),+; $file_iri:literal) => { {
-                test_hyperlink!($($columns),+; concat!("‹«👉", $file_iri, "»›"); FileIri)
-            } };
-        }
-
-        #[cfg(not(target_os = "windows"))]
-        #[test]
-        fn absolute_file_iri() {
-            test_file_iri!("file:///test/cool/index.rs");
-            test_file_iri!("file:///test/cool/");
-        }
-
-        mod issues {
-            #[cfg(not(target_os = "windows"))]
-            #[test]
-            #[should_panic(expected = "Path = «/test/Ῥόδος/», at grid cells (0, 0)..=(15, 1)")]
-            fn issue_file_iri_with_percent_encoded_characters() {
-                // Non-space characters
-                // file:///test/Ῥόδος/
-                test_file_iri!("file:///test/%E1%BF%AC%CF%8C%CE%B4%CE%BF%CF%82/"); // URI
-
-                // Spaces
-                test_file_iri!("file:///te%20st/co%20ol/index.rs");
-                test_file_iri!("file:///te%20st/co%20ol/");
-            }
-        }
-
-        #[cfg(target_os = "windows")]
-        mod windows {
-            mod issues {
-                // The test uses Url::to_file_path(), but it seems that the Url crate doesn't
-                // support relative file IRIs.
-                #[test]
-                #[should_panic(
-                    expected = r#"Failed to interpret file IRI `file:/test/cool/index.rs` as a path"#
-                )]
-                fn issue_relative_file_iri() {
-                    test_file_iri!("file:/test/cool/index.rs");
-                    test_file_iri!("file:/test/cool/");
-                }
-
-                // See https://en.wikipedia.org/wiki/File_URI_scheme
-                #[test]
-                #[should_panic(
-                    expected = r#"Path = «C:\\test\\cool\\index.rs», at grid cells (0, 0)..=(9, 1)"#
-                )]
-                fn issue_absolute_file_iri() {
-                    test_file_iri!("file:///C:/test/cool/index.rs");
-                    test_file_iri!("file:///C:/test/cool/");
-                }
-
-                #[test]
-                #[should_panic(
-                    expected = r#"Path = «C:\\test\\Ῥόδος\\», at grid cells (0, 0)..=(16, 1)"#
-                )]
-                fn issue_file_iri_with_percent_encoded_characters() {
-                    // Non-space characters
-                    // file:///test/Ῥόδος/
-                    test_file_iri!("file:///C:/test/%E1%BF%AC%CF%8C%CE%B4%CE%BF%CF%82/"); // URI
-
-                    // Spaces
-                    test_file_iri!("file:///C:/te%20st/co%20ol/index.rs");
-                    test_file_iri!("file:///C:/te%20st/co%20ol/");
-                }
-            }
-        }
-    }
-
-    mod iri {
-        /// [**`c₀, c₁, …, cₙ;`**]ₒₚₜ := use specified terminal widths of `c₀, c₁, …, cₙ` **columns**
-        /// (defaults to `3, longest_line_cells / 2, longest_line_cells + 1;`)
-        ///
-        macro_rules! test_iri {
-            ($iri:literal) => { { test_hyperlink!(concat!("‹«👉", $iri, "»›"); Iri) } };
-            ($($columns:literal),+; $iri:literal) => { {
-                test_hyperlink!($($columns),+; concat!("‹«👉", $iri, "»›"); Iri)
-            } };
-        }
-
-        #[test]
-        fn simple() {
-            // In the order they appear in URL_REGEX, except 'file://' which is treated as a path
-            test_iri!("ipfs://test/cool.ipfs");
-            test_iri!("ipns://test/cool.ipns");
-            test_iri!("magnet://test/cool.git");
-            test_iri!("mailto:someone@somewhere.here");
-            test_iri!("gemini://somewhere.here");
-            test_iri!("gopher://somewhere.here");
-            test_iri!("http://test/cool/index.html");
-            test_iri!("http://10.10.10.10:1111/cool.html");
-            test_iri!("http://test/cool/index.html?amazing=1");
-            test_iri!("http://test/cool/index.html#right%20here");
-            test_iri!("http://test/cool/index.html?amazing=1#right%20here");
-            test_iri!("https://test/cool/index.html");
-            test_iri!("https://10.10.10.10:1111/cool.html");
-            test_iri!("https://test/cool/index.html?amazing=1");
-            test_iri!("https://test/cool/index.html#right%20here");
-            test_iri!("https://test/cool/index.html?amazing=1#right%20here");
-            test_iri!("news://test/cool.news");
-            test_iri!("git://test/cool.git");
-            test_iri!("ssh://user@somewhere.over.here:12345/test/cool.git");
-            test_iri!("ftp://test/cool.ftp");
-        }
-
-        #[test]
-        fn wide_chars() {
-            // In the order they appear in URL_REGEX, except 'file://' which is treated as a path
-            test_iri!(4, 20; "ipfs://例🏃🦀/cool.ipfs");
-            test_iri!(4, 20; "ipns://例🏃🦀/cool.ipns");
-            test_iri!(6, 20; "magnet://例🏃🦀/cool.git");
-            test_iri!(4, 20; "mailto:someone@somewhere.here");
-            test_iri!(4, 20; "gemini://somewhere.here");
-            test_iri!(4, 20; "gopher://somewhere.here");
-            test_iri!(4, 20; "http://例🏃🦀/cool/index.html");
-            test_iri!(4, 20; "http://10.10.10.10:1111/cool.html");
-            test_iri!(4, 20; "http://例🏃🦀/cool/index.html?amazing=1");
-            test_iri!(4, 20; "http://例🏃🦀/cool/index.html#right%20here");
-            test_iri!(4, 20; "http://例🏃🦀/cool/index.html?amazing=1#right%20here");
-            test_iri!(4, 20; "https://例🏃🦀/cool/index.html");
-            test_iri!(4, 20; "https://10.10.10.10:1111/cool.html");
-            test_iri!(4, 20; "https://例🏃🦀/cool/index.html?amazing=1");
-            test_iri!(4, 20; "https://例🏃🦀/cool/index.html#right%20here");
-            test_iri!(4, 20; "https://例🏃🦀/cool/index.html?amazing=1#right%20here");
-            test_iri!(4, 20; "news://例🏃🦀/cool.news");
-            test_iri!(5, 20; "git://例/cool.git");
-            test_iri!(5, 20; "ssh://user@somewhere.over.here:12345/例🏃🦀/cool.git");
-            test_iri!(7, 20; "ftp://例🏃🦀/cool.ftp");
-        }
-
-        // There are likely more tests needed for IRI vs URI
-        #[test]
-        fn iris() {
-            // These refer to the same location, see example here:
-            // <https://en.wikipedia.org/wiki/Internationalized_Resource_Identifier#Compatibility>
-            test_iri!("https://en.wiktionary.org/wiki/Ῥόδος"); // IRI
-            test_iri!("https://en.wiktionary.org/wiki/%E1%BF%AC%CF%8C%CE%B4%CE%BF%CF%82"); // URI
-        }
-
-        #[test]
-        #[should_panic(expected = "Expected a path, but was a iri")]
-        fn file_is_a_path() {
-            test_iri!("file://test/cool/index.rs");
-        }
-    }
-
-    #[derive(Debug, PartialEq)]
-    enum HyperlinkKind {
-        FileIri,
-        Iri,
-        Path,
-    }
-
-    struct ExpectedHyperlink {
-        hovered_grid_point: AlacPoint,
-        hovered_char: char,
-        hyperlink_kind: HyperlinkKind,
-        iri_or_path: String,
-        row: Option<u32>,
-        column: Option<u32>,
-        hyperlink_match: RangeInclusive<AlacPoint>,
-    }
-
-    /// Converts to Windows style paths on Windows, like path!(), but at runtime for improved test
-    /// readability.
-    fn build_term_from_test_lines<'a>(
-        hyperlink_kind: HyperlinkKind,
-        term_size: TermSize,
-        test_lines: impl Iterator<Item = &'a str>,
-    ) -> (Term<VoidListener>, ExpectedHyperlink) {
-        #[derive(Default, Eq, PartialEq)]
-        enum HoveredState {
-            #[default]
-            HoveredScan,
-            HoveredNextChar,
-            Done,
-        }
-
-        #[derive(Default, Eq, PartialEq)]
-        enum MatchState {
-            #[default]
-            MatchScan,
-            MatchNextChar,
-            Match(AlacPoint),
-            Done,
-        }
-
-        #[derive(Default, Eq, PartialEq)]
-        enum CapturesState {
-            #[default]
-            PathScan,
-            PathNextChar,
-            Path(AlacPoint),
-            RowScan,
-            Row(String),
-            ColumnScan,
-            Column(String),
-            Done,
-        }
-
-        fn prev_input_point_from_term(term: &Term<VoidListener>) -> AlacPoint {
-            let grid = term.grid();
-            let cursor = &grid.cursor;
-            let mut point = cursor.point;
-
-            if !cursor.input_needs_wrap {
-                point.column -= 1;
-            }
-
-            if grid.index(point).flags.contains(Flags::WIDE_CHAR_SPACER) {
-                point.column -= 1;
-            }
-
-            point
-        }
-
-        let mut hovered_grid_point: Option<AlacPoint> = None;
-        let mut hyperlink_match = AlacPoint::default()..=AlacPoint::default();
-        let mut iri_or_path = String::default();
-        let mut row = None;
-        let mut column = None;
-        let mut prev_input_point = AlacPoint::default();
-        let mut hovered_state = HoveredState::default();
-        let mut match_state = MatchState::default();
-        let mut captures_state = CapturesState::default();
-        let mut term = Term::new(Config::default(), &term_size, VoidListener);
-
-        for text in test_lines {
-            let chars: Box<dyn Iterator<Item = char>> =
-                if cfg!(windows) && hyperlink_kind == HyperlinkKind::Path {
-                    Box::new(text.chars().map(|c| if c == '/' { '\\' } else { c })) as _
-                } else {
-                    Box::new(text.chars()) as _
-                };
-            let mut chars = chars.peekable();
-            while let Some(c) = chars.next() {
-                match c {
-                    '👉' => {
-                        hovered_state = HoveredState::HoveredNextChar;
-                    }
-                    '👈' => {
-                        hovered_grid_point = Some(prev_input_point.add(&term, Boundary::Grid, 1));
-                    }
-                    '«' | '»' => {
-                        captures_state = match captures_state {
-                            CapturesState::PathScan => CapturesState::PathNextChar,
-                            CapturesState::PathNextChar => {
-                                panic!("Should have been handled by char input")
-                            }
-                            CapturesState::Path(start_point) => {
-                                iri_or_path = term.bounds_to_string(start_point, prev_input_point);
-                                CapturesState::RowScan
-                            }
-                            CapturesState::RowScan => CapturesState::Row(String::new()),
-                            CapturesState::Row(number) => {
-                                row = Some(number.parse::<u32>().unwrap());
-                                CapturesState::ColumnScan
-                            }
-                            CapturesState::ColumnScan => CapturesState::Column(String::new()),
-                            CapturesState::Column(number) => {
-                                column = Some(number.parse::<u32>().unwrap());
-                                CapturesState::Done
-                            }
-                            CapturesState::Done => {
-                                panic!("Extra '«', '»'")
-                            }
-                        }
-                    }
-                    '‹' | '›' => {
-                        match_state = match match_state {
-                            MatchState::MatchScan => MatchState::MatchNextChar,
-                            MatchState::MatchNextChar => {
-                                panic!("Should have been handled by char input")
-                            }
-                            MatchState::Match(start_point) => {
-                                hyperlink_match = start_point..=prev_input_point;
-                                MatchState::Done
-                            }
-                            MatchState::Done => {
-                                panic!("Extra '‹', '›'")
-                            }
-                        }
-                    }
-                    _ => {
-                        if let CapturesState::Row(number) | CapturesState::Column(number) =
-                            &mut captures_state
-                        {
-                            number.push(c)
-                        }
-
-                        let is_windows_abs_path_start = captures_state
-                            == CapturesState::PathNextChar
-                            && cfg!(windows)
-                            && hyperlink_kind == HyperlinkKind::Path
-                            && c == '\\'
-                            && chars.peek().is_some_and(|c| *c != '\\');
-
-                        if is_windows_abs_path_start {
-                            // Convert Unix abs path start into Windows abs path start so that the
-                            // same test can be used for both OSes.
-                            term.input('C');
-                            prev_input_point = prev_input_point_from_term(&term);
-                            term.input(':');
-                            term.input(c);
-                        } else {
-                            term.input(c);
-                            prev_input_point = prev_input_point_from_term(&term);
-                        }
-
-                        if hovered_state == HoveredState::HoveredNextChar {
-                            hovered_grid_point = Some(prev_input_point);
-                            hovered_state = HoveredState::Done;
-                        }
-                        if captures_state == CapturesState::PathNextChar {
-                            captures_state = CapturesState::Path(prev_input_point);
-                        }
-                        if match_state == MatchState::MatchNextChar {
-                            match_state = MatchState::Match(prev_input_point);
-                        }
-                    }
-                }
-            }
-            term.move_down_and_cr(1);
-        }
-
-        if hyperlink_kind == HyperlinkKind::FileIri {
-            let Ok(url) = Url::parse(&iri_or_path) else {
-                panic!("Failed to parse file IRI `{iri_or_path}`");
-            };
-            let Ok(path) = url.to_file_path() else {
-                panic!("Failed to interpret file IRI `{iri_or_path}` as a path");
-            };
-            iri_or_path = path.to_string_lossy().to_string();
-        }
-
-        if cfg!(windows) {
-            // Handle verbatim and UNC paths for Windows
-            if let Some(stripped) = iri_or_path.strip_prefix(r#"\\?\UNC\"#) {
-                iri_or_path = format!(r#"\\{stripped}"#);
-            } else if let Some(stripped) = iri_or_path.strip_prefix(r#"\\?\"#) {
-                iri_or_path = stripped.to_string();
-            }
-        }
-
-        let hovered_grid_point = hovered_grid_point.expect("Missing hovered point (👉 or 👈)");
-        let hovered_char = term.grid().index(hovered_grid_point).c;
-        (
-            term,
-            ExpectedHyperlink {
-                hovered_grid_point,
-                hovered_char,
-                hyperlink_kind,
-                iri_or_path,
-                row,
-                column,
-                hyperlink_match,
-            },
-        )
-    }
-
-    fn line_cells_count(line: &str) -> usize {
-        // This avoids taking a dependency on the unicode-width crate
-        fn width(c: char) -> usize {
-            match c {
-                // Fullwidth unicode characters used in tests
-                '例' | '🏃' | '🦀' | '🔥' => 2,
-                _ => 1,
-            }
-        }
-        const CONTROL_CHARS: &str = "‹«👉👈»›";
-        line.chars()
-            .filter(|c| !CONTROL_CHARS.contains(*c))
-            .map(width)
-            .sum::<usize>()
-    }
-
-    struct CheckHyperlinkMatch<'a> {
-        term: &'a Term<VoidListener>,
-        expected_hyperlink: &'a ExpectedHyperlink,
-        source_location: &'a str,
-    }
-
-    impl<'a> CheckHyperlinkMatch<'a> {
-        fn new(
-            term: &'a Term<VoidListener>,
-            expected_hyperlink: &'a ExpectedHyperlink,
-            source_location: &'a str,
-        ) -> Self {
-            Self {
-                term,
-                expected_hyperlink,
-                source_location,
-            }
-        }
-
-        fn check_path_with_position_and_match(
-            &self,
-            path_with_position: PathWithPosition,
-            hyperlink_match: &Match,
-        ) {
-            let format_path_with_position_and_match =
-                |path_with_position: &PathWithPosition, hyperlink_match: &Match| {
-                    let mut result =
-                        format!("Path = «{}»", &path_with_position.path.to_string_lossy());
-                    if let Some(row) = path_with_position.row {
-                        result += &format!(", line = {row}");
-                        if let Some(column) = path_with_position.column {
-                            result += &format!(", column = {column}");
-                        }
-                    }
-
-                    result += &format!(
-                        ", at grid cells {}",
-                        Self::format_hyperlink_match(hyperlink_match)
-                    );
-                    result
-                };
-
-            assert_ne!(
-                self.expected_hyperlink.hyperlink_kind,
-                HyperlinkKind::Iri,
-                "\n    at {}\nExpected a path, but was a iri:\n{}",
-                self.source_location,
-                self.format_renderable_content()
-            );
-
-            assert_eq!(
-                format_path_with_position_and_match(
-                    &PathWithPosition {
-                        path: PathBuf::from(self.expected_hyperlink.iri_or_path.clone()),
-                        row: self.expected_hyperlink.row,
-                        column: self.expected_hyperlink.column
-                    },
-                    &self.expected_hyperlink.hyperlink_match
-                ),
-                format_path_with_position_and_match(&path_with_position, hyperlink_match),
-                "\n    at {}:\n{}",
-                self.source_location,
-                self.format_renderable_content()
-            );
-        }
-
-        fn check_iri_and_match(&self, iri: String, hyperlink_match: &Match) {
-            let format_iri_and_match = |iri: &String, hyperlink_match: &Match| {
-                format!(
-                    "Url = «{iri}», at grid cells {}",
-                    Self::format_hyperlink_match(hyperlink_match)
-                )
-            };
-
-            assert_eq!(
-                self.expected_hyperlink.hyperlink_kind,
-                HyperlinkKind::Iri,
-                "\n    at {}\nExpected a iri, but was a path:\n{}",
-                self.source_location,
-                self.format_renderable_content()
-            );
-
-            assert_eq!(
-                format_iri_and_match(
-                    &self.expected_hyperlink.iri_or_path,
-                    &self.expected_hyperlink.hyperlink_match
-                ),
-                format_iri_and_match(&iri, hyperlink_match),
-                "\n    at {}:\n{}",
-                self.source_location,
-                self.format_renderable_content()
-            );
-        }
-
-        fn format_hyperlink_match(hyperlink_match: &Match) -> String {
-            format!(
-                "({}, {})..=({}, {})",
-                hyperlink_match.start().line.0,
-                hyperlink_match.start().column.0,
-                hyperlink_match.end().line.0,
-                hyperlink_match.end().column.0
-            )
-        }
-
-        fn format_renderable_content(&self) -> String {
-            let mut result = format!("\nHovered on '{}'\n", self.expected_hyperlink.hovered_char);
-
-            let mut first_header_row = String::new();
-            let mut second_header_row = String::new();
-            let mut marker_header_row = String::new();
-            for index in 0..self.term.columns() {
-                let remainder = index % 10;
-                first_header_row.push_str(
-                    &(index > 0 && remainder == 0)
-                        .then_some((index / 10).to_string())
-                        .unwrap_or(" ".into()),
-                );
-                second_header_row += &remainder.to_string();
-                if index == self.expected_hyperlink.hovered_grid_point.column.0 {
-                    marker_header_row.push('↓');
-                } else {
-                    marker_header_row.push(' ');
-                }
-            }
-
-            result += &format!("\n      [{}]\n", first_header_row);
-            result += &format!("      [{}]\n", second_header_row);
-            result += &format!("       {}", marker_header_row);
-
-            let spacers: Flags = Flags::LEADING_WIDE_CHAR_SPACER | Flags::WIDE_CHAR_SPACER;
-            for cell in self
-                .term
-                .renderable_content()
-                .display_iter
-                .filter(|cell| !cell.flags.intersects(spacers))
-            {
-                if cell.point.column.0 == 0 {
-                    let prefix =
-                        if cell.point.line == self.expected_hyperlink.hovered_grid_point.line {
-                            '→'
-                        } else {
-                            ' '
-                        };
-                    result += &format!("\n{prefix}[{:>3}] ", cell.point.line.to_string());
-                }
-
-                result.push(cell.c);
-            }
-
-            result
-        }
-    }
-
-    fn test_hyperlink<'a>(
-        columns: usize,
-        total_cells: usize,
-        test_lines: impl Iterator<Item = &'a str>,
-        hyperlink_kind: HyperlinkKind,
-        source_location: &str,
-    ) {
-        thread_local! {
-            static TEST_REGEX_SEARCHES: RefCell<RegexSearches> = RefCell::new(RegexSearches::new());
-        }
-
-        let term_size = TermSize::new(columns, total_cells / columns + 2);
-        let (term, expected_hyperlink) =
-            build_term_from_test_lines(hyperlink_kind, term_size, test_lines);
-        let hyperlink_found = TEST_REGEX_SEARCHES.with(|regex_searches| {
-            find_from_grid_point(
-                &term,
-                expected_hyperlink.hovered_grid_point,
-                &mut regex_searches.borrow_mut(),
-            )
-        });
-        let check_hyperlink_match =
-            CheckHyperlinkMatch::new(&term, &expected_hyperlink, source_location);
-        match hyperlink_found {
-            Some((hyperlink_word, false, hyperlink_match)) => {
-                check_hyperlink_match.check_path_with_position_and_match(
-                    PathWithPosition::parse_str(&hyperlink_word),
-                    &hyperlink_match,
-                );
-            }
-            Some((hyperlink_word, true, hyperlink_match)) => {
-                check_hyperlink_match.check_iri_and_match(hyperlink_word, &hyperlink_match);
-            }
-            _ => {
-                assert!(
-                    false,
-                    "No hyperlink found\n     at {source_location}:\n{}",
-                    check_hyperlink_match.format_renderable_content()
-                )
-            }
-        }
-    }
-}
+use alacritty_terminal::{
+    Term,
+    event::EventListener,
+    grid::Dimensions,
+    index::{Boundary, Column, Direction as AlacDirection, Line, Point as AlacPoint},
+    term::search::{Match, RegexIter, RegexSearch},
+};
+use regex::Regex;
+use std::{ops::Index, sync::LazyLock};
+
+const URL_REGEX: &str = r#"(ipfs:|ipns:|magnet:|mailto:|gemini://|gopher://|https://|http://|news:|file://|git://|ssh:|ftp://)[^\u{0000}-\u{001F}\u{007F}-\u{009F}<>"\s{-}\^⟨⟩`']+"#;
+// Optional suffix matches MSBuild diagnostic suffixes for path parsing in PathLikeWithPosition
+// https://learn.microsoft.com/en-us/visualstudio/msbuild/msbuild-diagnostic-format-for-tasks
+const WORD_REGEX: &str =
+    r#"[\$\+\w.\[\]:/\\@\-~()]+(?:\((?:\d+|\d+,\d+)\))|[\$\+\w.\[\]:/\\@\-~()]+"#;
+
+const PYTHON_FILE_LINE_REGEX: &str = r#"File "(?P<file>[^"]+)", line (?P<line>\d+)"#;
+
+static PYTHON_FILE_LINE_MATCHER: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(PYTHON_FILE_LINE_REGEX).unwrap());
+
+fn python_extract_path_and_line(input: &str) -> Option<(&str, u32)> {
+    if let Some(captures) = PYTHON_FILE_LINE_MATCHER.captures(input) {
+        let path_part = captures.name("file")?.as_str();
+
+        let line_number: u32 = captures.name("line")?.as_str().parse().ok()?;
+        return Some((path_part, line_number));
+    }
+    None
+}
+
+pub(super) struct RegexSearches {
+    url_regex: RegexSearch,
+    word_regex: RegexSearch,
+    python_file_line_regex: RegexSearch,
+}
+
+impl RegexSearches {
+    pub(super) fn new() -> Self {
+        Self {
+            url_regex: RegexSearch::new(URL_REGEX).unwrap(),
+            word_regex: RegexSearch::new(WORD_REGEX).unwrap(),
+            python_file_line_regex: RegexSearch::new(PYTHON_FILE_LINE_REGEX).unwrap(),
+        }
+    }
+}
+
+pub(super) fn find_from_grid_point<T: EventListener>(
+    term: &Term<T>,
+    point: AlacPoint,
+    regex_searches: &mut RegexSearches,
+) -> Option<(String, bool, Match)> {
+    let grid = term.grid();
+    let link = grid.index(point).hyperlink();
+    let found_word = if let Some(ref url) = link {
+        let mut min_index = point;
+        loop {
+            let new_min_index = min_index.sub(term, Boundary::Cursor, 1);
+            if new_min_index == min_index || grid.index(new_min_index).hyperlink() != link {
+                break;
+            } else {
+                min_index = new_min_index
+            }
+        }
+
+        let mut max_index = point;
+        loop {
+            let new_max_index = max_index.add(term, Boundary::Cursor, 1);
+            if new_max_index == max_index || grid.index(new_max_index).hyperlink() != link {
+                break;
+            } else {
+                max_index = new_max_index
+            }
+        }
+
+        let url = url.uri().to_owned();
+        let url_match = min_index..=max_index;
+
+        Some((url, true, url_match))
+    } else if let Some(url_match) = regex_match_at(term, point, &mut regex_searches.url_regex) {
+        let url = term.bounds_to_string(*url_match.start(), *url_match.end());
+        Some((url, true, url_match))
+    } else if let Some(python_match) =
+        regex_match_at(term, point, &mut regex_searches.python_file_line_regex)
+    {
+        let matching_line = term.bounds_to_string(*python_match.start(), *python_match.end());
+        python_extract_path_and_line(&matching_line).map(|(file_path, line_number)| {
+            (format!("{file_path}:{line_number}"), false, python_match)
+        })
+    } else if let Some(word_match) = regex_match_at(term, point, &mut regex_searches.word_regex) {
+        let file_path = term.bounds_to_string(*word_match.start(), *word_match.end());
+
+        let (sanitized_match, sanitized_word) = 'sanitize: {
+            let mut word_match = word_match;
+            let mut file_path = file_path;
+
+            if is_path_surrounded_by_common_symbols(&file_path) {
+                word_match = Match::new(
+                    word_match.start().add(term, Boundary::Grid, 1),
+                    word_match.end().sub(term, Boundary::Grid, 1),
+                );
+                file_path = file_path[1..file_path.len() - 1].to_owned();
+            }
+
+            while file_path.ends_with(':') {
+                file_path.pop();
+                word_match = Match::new(
+                    *word_match.start(),
+                    word_match.end().sub(term, Boundary::Grid, 1),
+                );
+            }
+            let mut colon_count = 0;
+            for c in file_path.chars() {
+                if c == ':' {
+                    colon_count += 1;
+                }
+            }
+            // strip trailing comment after colon in case of
+            // file/at/path.rs:row:column:description or error message
+            // so that the file path is `file/at/path.rs:row:column`
+            if colon_count > 2 {
+                let last_index = file_path.rfind(':').unwrap();
+                let prev_is_digit = last_index > 0
+                    && file_path
+                        .chars()
+                        .nth(last_index - 1)
+                        .is_some_and(|c| c.is_ascii_digit());
+                let next_is_digit = last_index < file_path.len() - 1
+                    && file_path
+                        .chars()
+                        .nth(last_index + 1)
+                        .is_none_or(|c| c.is_ascii_digit());
+                if prev_is_digit && !next_is_digit {
+                    let stripped_len = file_path.len() - last_index;
+                    word_match = Match::new(
+                        *word_match.start(),
+                        word_match.end().sub(term, Boundary::Grid, stripped_len),
+                    );
+                    file_path = file_path[0..last_index].to_owned();
+                }
+            }
+
+            break 'sanitize (word_match, file_path);
+        };
+
+        Some((sanitized_word, false, sanitized_match))
+    } else {
+        None
+    };
+
+    found_word.map(|(maybe_url_or_path, is_url, word_match)| {
+        if is_url {
+            // Treat "file://" IRIs like file paths to ensure
+            // that line numbers at the end of the path are
+            // handled correctly
+            if let Some(path) = maybe_url_or_path.strip_prefix("file://") {
+                (path.to_string(), false, word_match)
+            } else {
+                (maybe_url_or_path, true, word_match)
+            }
+        } else {
+            (maybe_url_or_path, false, word_match)
+        }
+    })
+}
+
+fn is_path_surrounded_by_common_symbols(path: &str) -> bool {
+    // Avoid detecting `[]` or `()` strings as paths, surrounded by common symbols
+    path.len() > 2
+        // The rest of the brackets and various quotes cannot be matched by the [`WORD_REGEX`] hence not checked for.
+        && (path.starts_with('[') && path.ends_with(']')
+            || path.starts_with('(') && path.ends_with(')'))
+}
+
+/// Based on alacritty/src/display/hint.rs > regex_match_at
+/// Retrieve the match, if the specified point is inside the content matching the regex.
+fn regex_match_at<T>(term: &Term<T>, point: AlacPoint, regex: &mut RegexSearch) -> Option<Match> {
+    visible_regex_match_iter(term, regex).find(|rm| rm.contains(&point))
+}
+
+/// Copied from alacritty/src/display/hint.rs:
+/// Iterate over all visible regex matches.
+fn visible_regex_match_iter<'a, T>(
+    term: &'a Term<T>,
+    regex: &'a mut RegexSearch,
+) -> impl Iterator<Item = Match> + 'a {
+    const MAX_SEARCH_LINES: usize = 100;
+
+    let viewport_start = Line(-(term.grid().display_offset() as i32));
+    let viewport_end = viewport_start + term.bottommost_line();
+    let mut start = term.line_search_left(AlacPoint::new(viewport_start, Column(0)));
+    let mut end = term.line_search_right(AlacPoint::new(viewport_end, Column(0)));
+    start.line = start.line.max(viewport_start - MAX_SEARCH_LINES);
+    end.line = end.line.min(viewport_end + MAX_SEARCH_LINES);
+
+    RegexIter::new(start, end, AlacDirection::Right, term, regex)
+        .skip_while(move |rm| rm.end().line < viewport_start)
+        .take_while(move |rm| rm.start().line <= viewport_end)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use alacritty_terminal::{
+        event::VoidListener,
+        index::{Boundary, Point as AlacPoint},
+        term::{Config, cell::Flags, test::TermSize},
+        vte::ansi::Handler,
+    };
+    use std::{cell::RefCell, ops::RangeInclusive, path::PathBuf};
+    use url::Url;
+    use util::paths::PathWithPosition;
+
+    fn re_test(re: &str, hay: &str, expected: Vec<&str>) {
+        let results: Vec<_> = regex::Regex::new(re)
+            .unwrap()
+            .find_iter(hay)
+            .map(|m| m.as_str())
+            .collect();
+        assert_eq!(results, expected);
+    }
+
+    #[test]
+    fn test_url_regex() {
+        re_test(
+            URL_REGEX,
+            "test http://example.com test 'https://website1.com' test mailto:bob@example.com train",
+            vec![
+                "http://example.com",
+                "https://website1.com",
+                "mailto:bob@example.com",
+            ],
+        );
+    }
+
+    #[test]
+    fn test_word_regex() {
+        re_test(
+            WORD_REGEX,
+            "hello, world! \"What\" is this?",
+            vec!["hello", "world", "What", "is", "this"],
+        );
+    }
+
+    #[test]
+    fn test_word_regex_with_linenum() {
+        // filename(line) and filename(line,col) as used in MSBuild output
+        // should be considered a single "word", even though comma is
+        // usually a word separator
+        re_test(WORD_REGEX, "a Main.cs(20) b", vec!["a", "Main.cs(20)", "b"]);
+        re_test(
+            WORD_REGEX,
+            "Main.cs(20,5) Error desc",
+            vec!["Main.cs(20,5)", "Error", "desc"],
+        );
+        // filename:line:col is a popular format for unix tools
+        re_test(
+            WORD_REGEX,
+            "a Main.cs:20:5 b",
+            vec!["a", "Main.cs:20:5", "b"],
+        );
+        // Some tools output "filename:line:col:message", which currently isn't
+        // handled correctly, but might be in the future
+        re_test(
+            WORD_REGEX,
+            "Main.cs:20:5:Error desc",
+            vec!["Main.cs:20:5:Error", "desc"],
+        );
+    }
+
+    #[test]
+    fn test_python_file_line_regex() {
+        re_test(
+            PYTHON_FILE_LINE_REGEX,
+            "hay File \"/zed/bad_py.py\", line 8 stack",
+            vec!["File \"/zed/bad_py.py\", line 8"],
+        );
+        re_test(PYTHON_FILE_LINE_REGEX, "unrelated", vec![]);
+    }
+
+    #[test]
+    fn test_python_file_line() {
+        let inputs: Vec<(&str, Option<(&str, u32)>)> = vec![
+            (
+                "File \"/zed/bad_py.py\", line 8",
+                Some(("/zed/bad_py.py", 8u32)),
+            ),
+            ("File \"path/to/zed/bad_py.py\"", None),
+            ("unrelated", None),
+            ("", None),
+        ];
+        let actual = inputs
+            .iter()
+            .map(|input| python_extract_path_and_line(input.0))
+            .collect::<Vec<_>>();
+        let expected = inputs.iter().map(|(_, output)| *output).collect::<Vec<_>>();
+        assert_eq!(actual, expected);
+    }
+
+    // We use custom columns in many tests to workaround this issue by ensuring a wrapped
+    // line never ends on a wide char:
+    //
+    // <https://github.com/alacritty/alacritty/issues/8586>
+    //
+    // This issue was recently fixed, as soon as we update to a version containing the fix we
+    // can remove all the custom columns from these tests.
+    //
+    macro_rules! test_hyperlink {
+        ($($lines:expr),+; $hyperlink_kind:ident) => { {
+            use crate::terminal_hyperlinks::tests::line_cells_count;
+            use std::cmp;
+
+            let test_lines = vec![$($lines),+];
+            let (total_cells, longest_line_cells) =
+                test_lines.iter().copied()
+                    .map(line_cells_count)
+                    .fold((0, 0), |state, cells| (state.0 + cells, cmp::max(state.1, cells)));
+
+            test_hyperlink!(
+                // Alacritty has issues with 2 columns, use 3 as the minimum for now.
+                [3, longest_line_cells / 2, longest_line_cells + 1];
+                total_cells;
+                test_lines.iter().copied();
+                $hyperlink_kind
+            )
+        } };
+
+        ($($columns:literal),+; $($lines:expr),+; $hyperlink_kind:ident) => { {
+            use crate::terminal_hyperlinks::tests::line_cells_count;
+
+            let test_lines = vec![$($lines),+];
+            let total_cells = test_lines.iter().copied().map(line_cells_count).sum();
+
+            test_hyperlink!(
+                [ $($columns),+ ]; total_cells; test_lines.iter().copied(); $hyperlink_kind
+            )
+        } };
+
+        ([ $($columns:expr),+ ]; $total_cells:expr; $lines:expr; $hyperlink_kind:ident) => { {
+            use crate::terminal_hyperlinks::tests::{ test_hyperlink, HyperlinkKind };
+
+            let source_location = format!("{}:{}", std::file!(), std::line!());
+            for columns in vec![ $($columns),+] {
+                test_hyperlink(columns, $total_cells, $lines, HyperlinkKind::$hyperlink_kind,
+                    &source_location);
+            }
+        } };
+    }
+
+    mod path {
+        /// 👉 := **hovered** on following char
+        ///
+        /// 👈 := **hovered** on wide char spacer of previous full width char
+        ///
+        /// **`‹›`** := expected **hyperlink** match
+        ///
+        /// **`«»`** := expected **path**, **row**, and **column** capture groups
+        ///
+        /// [**`c₀, c₁, …, cₙ;`**]ₒₚₜ := use specified terminal widths of `c₀, c₁, …, cₙ` **columns**
+        /// (defaults to `3, longest_line_cells / 2, longest_line_cells + 1;`)
+        ///
+        macro_rules! test_path {
+            ($($lines:literal),+) => { test_hyperlink!($($lines),+; Path) };
+            ($($columns:literal),+; $($lines:literal),+) => {
+                test_hyperlink!($($columns),+; $($lines),+; Path)
+            };
+        }
+
+        #[test]
+        fn simple() {
+            // Rust paths
+            // Just the path
+            test_path!("‹«/👉test/cool.rs»›");
+            test_path!("‹«/test/cool👉.rs»›");
+
+            // path and line
+            test_path!("‹«/👉test/cool.rs»:«4»›");
+            test_path!("‹«/test/cool.rs»👉:«4»›");
+            test_path!("‹«/test/cool.rs»:«👉4»›");
+            test_path!("‹«/👉test/cool.rs»(«4»)›");
+            test_path!("‹«/test/cool.rs»👉(«4»)›");
+            test_path!("‹«/test/cool.rs»(«👉4»)›");
+            test_path!("‹«/test/cool.rs»(«4»👉)›");
+
+            // path, line, and column
+            test_path!("‹«/👉test/cool.rs»:«4»:«2»›");
+            test_path!("‹«/test/cool.rs»:«4»:«👉2»›");
+            test_path!("‹«/👉test/cool.rs»(«4»,«2»)›");
+            test_path!("‹«/test/cool.rs»(«4»👉,«2»)›");
+
+            // path, line, column, and ':' suffix
+            test_path!("‹«/👉test/cool.rs»:«4»:«2»›:");
+            test_path!("‹«/test/cool.rs»:«4»:«👉2»›:");
+            test_path!("‹«/👉test/cool.rs»(«4»,«2»)›:");
+            test_path!("‹«/test/cool.rs»(«4»,«2»👉)›:");
+
+            // path, line, column, and description
+            test_path!("‹«/test/cool.rs»:«4»:«2»›👉:Error!");
+            test_path!("‹«/test/cool.rs»:«4»:«2»›:👉Error!");
+            test_path!("‹«/test/co👉ol.rs»(«4»,«2»)›:Error!");
+
+            // Cargo output
+            test_path!("    Compiling Cool 👉(‹«/test/Cool»›)");
+            test_path!("    Compiling Cool (‹«/👉test/Cool»›)");
+            test_path!("    Compiling Cool (‹«/test/Cool»›👉)");
+
+            // Python
+            test_path!("‹«awe👉some.py»›");
+
+            test_path!("    ‹F👉ile \"«/awesome.py»\", line «42»›: Wat?");
+            test_path!("    ‹File \"«/awe👉some.py»\", line «42»›: Wat?");
+            test_path!("    ‹File \"«/awesome.py»👉\", line «42»›: Wat?");
+            test_path!("    ‹File \"«/awesome.py»\", line «4👉2»›: Wat?");
+        }
+
+        #[test]
+        fn colons_galore() {
+            test_path!("‹«/test/co👉ol.rs»:«4»›");
+            test_path!("‹«/test/co👉ol.rs»:«4»›:");
+            test_path!("‹«/test/co👉ol.rs»:«4»:«2»›");
+            test_path!("‹«/test/co👉ol.rs»:«4»:«2»›:");
+            test_path!("‹«/test/co👉ol.rs»(«1»)›");
+            test_path!("‹«/test/co👉ol.rs»(«1»)›:");
+            test_path!("‹«/test/co👉ol.rs»(«1»,«618»)›");
+            test_path!("‹«/test/co👉ol.rs»(«1»,«618»)›:");
+            test_path!("‹«/test/co👉ol.rs»::«42»›");
+            test_path!("‹«/test/co👉ol.rs»::«42»›:");
+            test_path!("‹«/test/co👉ol.rs:4:2»(«1»,«618»)›");
+            test_path!("‹«/test/co👉ol.rs»(«1»,«618»)›::");
+        }
+
+        #[test]
+        fn word_wide_chars() {
+            // Rust paths
+            test_path!(4, 6, 12; "‹«/👉例/cool.rs»›");
+            test_path!(4, 6, 12; "‹«/例👈/cool.rs»›");
+            test_path!(4, 8, 16; "‹«/例/cool.rs»:«👉4»›");
+            test_path!(4, 8, 16; "‹«/例/cool.rs»:«4»:«👉2»›");
+
+            // Cargo output
+            test_path!(4, 27, 30; "    Compiling Cool (‹«/👉例/Cool»›)");
+            test_path!(4, 27, 30; "    Compiling Cool (‹«/例👈/Cool»›)");
+
+            // Python
+            test_path!(4, 11; "‹«👉例wesome.py»›");
+            test_path!(4, 11; "‹«例👈wesome.py»›");
+            test_path!(6, 17, 40; "    ‹File \"«/👉例wesome.py»\", line «42»›: Wat?");
+            test_path!(6, 17, 40; "    ‹File \"«/例👈wesome.py»\", line «42»›: Wat?");
+        }
+
+        #[test]
+        fn non_word_wide_chars() {
+            // Mojo diagnostic message
+            test_path!(4, 18, 38; "    ‹File \"«/awe👉some.🔥»\", line «42»›: Wat?");
+            test_path!(4, 18, 38; "    ‹File \"«/awesome👉.🔥»\", line «42»›: Wat?");
+            test_path!(4, 18, 38; "    ‹File \"«/awesome.👉🔥»\", line «42»›: Wat?");
+            test_path!(4, 18, 38; "    ‹File \"«/awesome.🔥👈»\", line «42»›: Wat?");
+        }
+
+        /// These likely rise to the level of being worth fixing.
+        mod issues {
+            #[test]
+            #[cfg_attr(not(target_os = "windows"), should_panic(expected = "Path = «例»"))]
+            #[cfg_attr(target_os = "windows", should_panic(expected = r#"Path = «C:\\例»"#))]
+            // <https://github.com/alacritty/alacritty/issues/8586>
+            fn issue_alacritty_8586() {
+                // Rust paths
+                test_path!("‹«/👉例/cool.rs»›");
+                test_path!("‹«/例👈/cool.rs»›");
+                test_path!("‹«/例/cool.rs»:«👉4»›");
+                test_path!("‹«/例/cool.rs»:«4»:«👉2»›");
+
+                // Cargo output
+                test_path!("    Compiling Cool (‹«/👉例/Cool»›)");
+                test_path!("    Compiling Cool (‹«/例👈/Cool»›)");
+
+                // Python
+                test_path!("‹«👉例wesome.py»›");
+                test_path!("‹«例👈wesome.py»›");
+                test_path!("    ‹File \"«/👉例wesome.py»\", line «42»›: Wat?");
+                test_path!("    ‹File \"«/例👈wesome.py»\", line «42»›: Wat?");
+            }
+
+            #[test]
+            #[should_panic(expected = "No hyperlink found")]
+            // <https://github.com/zed-industries/zed/issues/12338>
+            fn issue_12338() {
+                // Issue #12338
+                test_path!(".rw-r--r--     0     staff 05-27 14:03 ‹«test👉、2.txt»›");
+                test_path!(".rw-r--r--     0     staff 05-27 14:03 ‹«test、👈2.txt»›");
+                test_path!(".rw-r--r--     0     staff 05-27 14:03 ‹«test👉。3.txt»›");
+                test_path!(".rw-r--r--     0     staff 05-27 14:03 ‹«test。👈3.txt»›");
+
+                // Rust paths
+                test_path!("‹«/👉🏃/🦀.rs»›");
+                test_path!("‹«/🏃👈/🦀.rs»›");
+                test_path!("‹«/🏃/👉🦀.rs»:«4»›");
+                test_path!("‹«/🏃/🦀👈.rs»:«4»:«2»›");
+
+                // Cargo output
+                test_path!("    Compiling Cool (‹«/👉🏃/Cool»›)");
+                test_path!("    Compiling Cool (‹«/🏃👈/Cool»›)");
+
+                // Python
+                test_path!("‹«👉🏃wesome.py»›");
+                test_path!("‹«🏃👈wesome.py»›");
+                test_path!("    ‹File \"«/👉🏃wesome.py»\", line «42»›: Wat?");
+                test_path!("    ‹File \"«/🏃👈wesome.py»\", line «42»›: Wat?");
+
+                // Mojo
+                test_path!("‹«/awe👉some.🔥»› is some good Mojo!");
+                test_path!("‹«/awesome👉.🔥»› is some good Mojo!");
+                test_path!("‹«/awesome.👉🔥»› is some good Mojo!");
+                test_path!("‹«/awesome.🔥👈»› is some good Mojo!");
+                test_path!("    ‹File \"«/👉🏃wesome.🔥»\", line «42»›: Wat?");
+                test_path!("    ‹File \"«/🏃👈wesome.🔥»\", line «42»›: Wat?");
+            }
+
+            #[test]
+            #[cfg_attr(
+                not(target_os = "windows"),
+                should_panic(
+                    expected = "Path = «test/controllers/template_items_controller_test.rb», line = 20, at grid cells (0, 0)..=(17, 1)"
+                )
+            )]
+            #[cfg_attr(
+                target_os = "windows",
+                should_panic(
+                    expected = r#"Path = «test\\controllers\\template_items_controller_test.rb», line = 20, at grid cells (0, 0)..=(17, 1)"#
+                )
+            )]
+            // <https://github.com/zed-industries/zed/issues/28194>
+            //
+            // #28194 was closed, but the link includes the description part (":in" here), which
+            // seems wrong...
+            fn issue_28194() {
+                test_path!(
+                    "‹«test/c👉ontrollers/template_items_controller_test.rb»:«20»›:in 'block (2 levels) in <class:TemplateItemsControllerTest>'"
+                );
+                test_path!(
+                    "‹«test/controllers/template_items_controller_test.rb»:«19»›:i👉n 'block in <class:TemplateItemsControllerTest>'"
+                );
+            }
+        }
+
+        /// Minor issues arguably not important enough to fix/workaround...
+        mod nits {
+            #[test]
+            #[cfg_attr(
+                not(target_os = "windows"),
+                should_panic(expected = "Path = «/test/cool.rs(4»")
+            )]
+            #[cfg_attr(
+                target_os = "windows",
+                should_panic(expected = r#"Path = «C:\\test\\cool.rs(4»"#)
+            )]
+            fn alacritty_bugs_with_two_columns() {
+                test_path!(2; "‹«/👉test/cool.rs»(«4»)›");
+                test_path!(2; "‹«/test/cool.rs»(«👉4»)›");
+                test_path!(2; "‹«/test/cool.rs»(«4»,«👉2»)›");
+
+                // Python
+                test_path!(2; "‹«awe👉some.py»›");
+            }
+
+            #[test]
+            #[cfg_attr(
+                not(target_os = "windows"),
+                should_panic(
+                    expected = "Path = «/test/cool.rs», line = 1, at grid cells (0, 0)..=(9, 0)"
+                )
+            )]
+            #[cfg_attr(
+                target_os = "windows",
+                should_panic(
+                    expected = r#"Path = «C:\\test\\cool.rs», line = 1, at grid cells (0, 0)..=(9, 2)"#
+                )
+            )]
+            fn invalid_row_column_should_be_part_of_path() {
+                test_path!("‹«/👉test/cool.rs:1:618033988749»›");
+                test_path!("‹«/👉test/cool.rs(1,618033988749)»›");
+            }
+
+            #[test]
+            #[should_panic(expected = "Path = «»")]
+            fn colon_suffix_succeeds_in_finding_an_empty_maybe_path() {
+                test_path!("‹«/test/cool.rs»:«4»:«2»›👉:", "What is this?");
+                test_path!("‹«/test/cool.rs»(«4»,«2»)›👉:", "What is this?");
+            }
+
+            #[test]
+            #[cfg_attr(
+                not(target_os = "windows"),
+                should_panic(expected = "Path = «/test/cool.rs»")
+            )]
+            #[cfg_attr(
+                target_os = "windows",
+                should_panic(expected = r#"Path = «C:\\test\\cool.rs»"#)
+            )]
+            fn many_trailing_colons_should_be_parsed_as_part_of_the_path() {
+                test_path!("‹«/test/cool.rs:::👉:»›");
+                test_path!("‹«/te:st/👉co:ol.r:s:4:2::::::»›");
+            }
+        }
+
+        #[cfg(target_os = "windows")]
+        mod windows {
+            // Lots of fun to be had with long file paths (verbatim) and UNC paths on Windows.
+            // See <https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation>
+            // See <https://users.rust-lang.org/t/understanding-windows-paths/58583>
+            // See <https://github.com/rust-lang/cargo/issues/13919>
+
+            #[test]
+            fn unc() {
+                test_path!(r#"‹«\\server\share\👉test\cool.rs»›"#);
+                test_path!(r#"‹«\\server\share\test\cool👉.rs»›"#);
+            }
+
+            mod issues {
+                #[test]
+                #[should_panic(
+                    expected = r#"Path = «C:\\test\\cool.rs», at grid cells (0, 0)..=(6, 0)"#
+                )]
+                fn issue_verbatim() {
+                    test_path!(r#"‹«\\?\C:\👉test\cool.rs»›"#);
+                    test_path!(r#"‹«\\?\C:\test\cool👉.rs»›"#);
+                }
+
+                #[test]
+                #[should_panic(
+                    expected = r#"Path = «\\\\server\\share\\test\\cool.rs», at grid cells (0, 0)..=(10, 2)"#
+                )]
+                fn issue_verbatim_unc() {
+                    test_path!(r#"‹«\\?\UNC\server\share\👉test\cool.rs»›"#);
+                    test_path!(r#"‹«\\?\UNC\server\share\test\cool👉.rs»›"#);
+                }
+            }
+        }
+    }
+
+    mod file_iri {
+        // File IRIs have a ton of use cases, most of which we currently do not support. A few of
+        // those cases are documented here as tests which are expected to fail.
+        // See https://en.wikipedia.org/wiki/File_URI_scheme
+
+        /// [**`c₀, c₁, …, cₙ;`**]ₒₚₜ := use specified terminal widths of `c₀, c₁, …, cₙ` **columns**
+        /// (defaults to `3, longest_line_cells / 2, longest_line_cells + 1;`)
+        ///
+        macro_rules! test_file_iri {
+            ($file_iri:literal) => { { test_hyperlink!(concat!("‹«👉", $file_iri, "»›"); FileIri) } };
+            ($($columns:literal),+; $file_iri:literal) => { {
+                test_hyperlink!($($columns),+; concat!("‹«👉", $file_iri, "»›"); FileIri)
+            } };
+        }
+
+        #[cfg(not(target_os = "windows"))]
+        #[test]
+        fn absolute_file_iri() {
+            test_file_iri!("file:///test/cool/index.rs");
+            test_file_iri!("file:///test/cool/");
+        }
+
+        mod issues {
+            #[cfg(not(target_os = "windows"))]
+            #[test]
+            #[should_panic(expected = "Path = «/test/Ῥόδος/», at grid cells (0, 0)..=(15, 1)")]
+            fn issue_file_iri_with_percent_encoded_characters() {
+                // Non-space characters
+                // file:///test/Ῥόδος/
+                test_file_iri!("file:///test/%E1%BF%AC%CF%8C%CE%B4%CE%BF%CF%82/"); // URI
+
+                // Spaces
+                test_file_iri!("file:///te%20st/co%20ol/index.rs");
+                test_file_iri!("file:///te%20st/co%20ol/");
+            }
+        }
+
+        #[cfg(target_os = "windows")]
+        mod windows {
+            mod issues {
+                // The test uses Url::to_file_path(), but it seems that the Url crate doesn't
+                // support relative file IRIs.
+                #[test]
+                #[should_panic(
+                    expected = r#"Failed to interpret file IRI `file:/test/cool/index.rs` as a path"#
+                )]
+                fn issue_relative_file_iri() {
+                    test_file_iri!("file:/test/cool/index.rs");
+                    test_file_iri!("file:/test/cool/");
+                }
+
+                // See https://en.wikipedia.org/wiki/File_URI_scheme
+                #[test]
+                #[should_panic(
+                    expected = r#"Path = «C:\\test\\cool\\index.rs», at grid cells (0, 0)..=(9, 1)"#
+                )]
+                fn issue_absolute_file_iri() {
+                    test_file_iri!("file:///C:/test/cool/index.rs");
+                    test_file_iri!("file:///C:/test/cool/");
+                }
+
+                #[test]
+                #[should_panic(
+                    expected = r#"Path = «C:\\test\\Ῥόδος\\», at grid cells (0, 0)..=(16, 1)"#
+                )]
+                fn issue_file_iri_with_percent_encoded_characters() {
+                    // Non-space characters
+                    // file:///test/Ῥόδος/
+                    test_file_iri!("file:///C:/test/%E1%BF%AC%CF%8C%CE%B4%CE%BF%CF%82/"); // URI
+
+                    // Spaces
+                    test_file_iri!("file:///C:/te%20st/co%20ol/index.rs");
+                    test_file_iri!("file:///C:/te%20st/co%20ol/");
+                }
+            }
+        }
+    }
+
+    mod iri {
+        /// [**`c₀, c₁, …, cₙ;`**]ₒₚₜ := use specified terminal widths of `c₀, c₁, …, cₙ` **columns**
+        /// (defaults to `3, longest_line_cells / 2, longest_line_cells + 1;`)
+        ///
+        macro_rules! test_iri {
+            ($iri:literal) => { { test_hyperlink!(concat!("‹«👉", $iri, "»›"); Iri) } };
+            ($($columns:literal),+; $iri:literal) => { {
+                test_hyperlink!($($columns),+; concat!("‹«👉", $iri, "»›"); Iri)
+            } };
+        }
+
+        #[test]
+        fn simple() {
+            // In the order they appear in URL_REGEX, except 'file://' which is treated as a path
+            test_iri!("ipfs://test/cool.ipfs");
+            test_iri!("ipns://test/cool.ipns");
+            test_iri!("magnet://test/cool.git");
+            test_iri!("mailto:someone@somewhere.here");
+            test_iri!("gemini://somewhere.here");
+            test_iri!("gopher://somewhere.here");
+            test_iri!("http://test/cool/index.html");
+            test_iri!("http://10.10.10.10:1111/cool.html");
+            test_iri!("http://test/cool/index.html?amazing=1");
+            test_iri!("http://test/cool/index.html#right%20here");
+            test_iri!("http://test/cool/index.html?amazing=1#right%20here");
+            test_iri!("https://test/cool/index.html");
+            test_iri!("https://10.10.10.10:1111/cool.html");
+            test_iri!("https://test/cool/index.html?amazing=1");
+            test_iri!("https://test/cool/index.html#right%20here");
+            test_iri!("https://test/cool/index.html?amazing=1#right%20here");
+            test_iri!("news://test/cool.news");
+            test_iri!("git://test/cool.git");
+            test_iri!("ssh://user@somewhere.over.here:12345/test/cool.git");
+            test_iri!("ftp://test/cool.ftp");
+        }
+
+        #[test]
+        fn wide_chars() {
+            // In the order they appear in URL_REGEX, except 'file://' which is treated as a path
+            test_iri!(4, 20; "ipfs://例🏃🦀/cool.ipfs");
+            test_iri!(4, 20; "ipns://例🏃🦀/cool.ipns");
+            test_iri!(6, 20; "magnet://例🏃🦀/cool.git");
+            test_iri!(4, 20; "mailto:someone@somewhere.here");
+            test_iri!(4, 20; "gemini://somewhere.here");
+            test_iri!(4, 20; "gopher://somewhere.here");
+            test_iri!(4, 20; "http://例🏃🦀/cool/index.html");
+            test_iri!(4, 20; "http://10.10.10.10:1111/cool.html");
+            test_iri!(4, 20; "http://例🏃🦀/cool/index.html?amazing=1");
+            test_iri!(4, 20; "http://例🏃🦀/cool/index.html#right%20here");
+            test_iri!(4, 20; "http://例🏃🦀/cool/index.html?amazing=1#right%20here");
+            test_iri!(4, 20; "https://例🏃🦀/cool/index.html");
+            test_iri!(4, 20; "https://10.10.10.10:1111/cool.html");
+            test_iri!(4, 20; "https://例🏃🦀/cool/index.html?amazing=1");
+            test_iri!(4, 20; "https://例🏃🦀/cool/index.html#right%20here");
+            test_iri!(4, 20; "https://例🏃🦀/cool/index.html?amazing=1#right%20here");
+            test_iri!(4, 20; "news://例🏃🦀/cool.news");
+            test_iri!(5, 20; "git://例/cool.git");
+            test_iri!(5, 20; "ssh://user@somewhere.over.here:12345/例🏃🦀/cool.git");
+            test_iri!(7, 20; "ftp://例🏃🦀/cool.ftp");
+        }
+
+        // There are likely more tests needed for IRI vs URI
+        #[test]
+        fn iris() {
+            // These refer to the same location, see example here:
+            // <https://en.wikipedia.org/wiki/Internationalized_Resource_Identifier#Compatibility>
+            test_iri!("https://en.wiktionary.org/wiki/Ῥόδος"); // IRI
+            test_iri!("https://en.wiktionary.org/wiki/%E1%BF%AC%CF%8C%CE%B4%CE%BF%CF%82"); // URI
+        }
+
+        #[test]
+        #[should_panic(expected = "Expected a path, but was a iri")]
+        fn file_is_a_path() {
+            test_iri!("file://test/cool/index.rs");
+        }
+    }
+
+    #[derive(Debug, PartialEq)]
+    enum HyperlinkKind {
+        FileIri,
+        Iri,
+        Path,
+    }
+
+    struct ExpectedHyperlink {
+        hovered_grid_point: AlacPoint,
+        hovered_char: char,
+        hyperlink_kind: HyperlinkKind,
+        iri_or_path: String,
+        row: Option<u32>,
+        column: Option<u32>,
+        hyperlink_match: RangeInclusive<AlacPoint>,
+    }
+
+    /// Converts to Windows style paths on Windows, like path!(), but at runtime for improved test
+    /// readability.
+    fn build_term_from_test_lines<'a>(
+        hyperlink_kind: HyperlinkKind,
+        term_size: TermSize,
+        test_lines: impl Iterator<Item = &'a str>,
+    ) -> (Term<VoidListener>, ExpectedHyperlink) {
+        #[derive(Default, Eq, PartialEq)]
+        enum HoveredState {
+            #[default]
+            HoveredScan,
+            HoveredNextChar,
+            Done,
+        }
+
+        #[derive(Default, Eq, PartialEq)]
+        enum MatchState {
+            #[default]
+            MatchScan,
+            MatchNextChar,
+            Match(AlacPoint),
+            Done,
+        }
+
+        #[derive(Default, Eq, PartialEq)]
+        enum CapturesState {
+            #[default]
+            PathScan,
+            PathNextChar,
+            Path(AlacPoint),
+            RowScan,
+            Row(String),
+            ColumnScan,
+            Column(String),
+            Done,
+        }
+
+        fn prev_input_point_from_term(term: &Term<VoidListener>) -> AlacPoint {
+            let grid = term.grid();
+            let cursor = &grid.cursor;
+            let mut point = cursor.point;
+
+            if !cursor.input_needs_wrap {
+                point.column -= 1;
+            }
+
+            if grid.index(point).flags.contains(Flags::WIDE_CHAR_SPACER) {
+                point.column -= 1;
+            }
+
+            point
+        }
+
+        let mut hovered_grid_point: Option<AlacPoint> = None;
+        let mut hyperlink_match = AlacPoint::default()..=AlacPoint::default();
+        let mut iri_or_path = String::default();
+        let mut row = None;
+        let mut column = None;
+        let mut prev_input_point = AlacPoint::default();
+        let mut hovered_state = HoveredState::default();
+        let mut match_state = MatchState::default();
+        let mut captures_state = CapturesState::default();
+        let mut term = Term::new(Config::default(), &term_size, VoidListener);
+
+        for text in test_lines {
+            let chars: Box<dyn Iterator<Item = char>> =
+                if cfg!(windows) && hyperlink_kind == HyperlinkKind::Path {
+                    Box::new(text.chars().map(|c| if c == '/' { '\\' } else { c })) as _
+                } else {
+                    Box::new(text.chars()) as _
+                };
+            let mut chars = chars.peekable();
+            while let Some(c) = chars.next() {
+                match c {
+                    '👉' => {
+                        hovered_state = HoveredState::HoveredNextChar;
+                    }
+                    '👈' => {
+                        hovered_grid_point = Some(prev_input_point.add(&term, Boundary::Grid, 1));
+                    }
+                    '«' | '»' => {
+                        captures_state = match captures_state {
+                            CapturesState::PathScan => CapturesState::PathNextChar,
+                            CapturesState::PathNextChar => {
+                                panic!("Should have been handled by char input")
+                            }
+                            CapturesState::Path(start_point) => {
+                                iri_or_path = term.bounds_to_string(start_point, prev_input_point);
+                                CapturesState::RowScan
+                            }
+                            CapturesState::RowScan => CapturesState::Row(String::new()),
+                            CapturesState::Row(number) => {
+                                row = Some(number.parse::<u32>().unwrap());
+                                CapturesState::ColumnScan
+                            }
+                            CapturesState::ColumnScan => CapturesState::Column(String::new()),
+                            CapturesState::Column(number) => {
+                                column = Some(number.parse::<u32>().unwrap());
+                                CapturesState::Done
+                            }
+                            CapturesState::Done => {
+                                panic!("Extra '«', '»'")
+                            }
+                        }
+                    }
+                    '‹' | '›' => {
+                        match_state = match match_state {
+                            MatchState::MatchScan => MatchState::MatchNextChar,
+                            MatchState::MatchNextChar => {
+                                panic!("Should have been handled by char input")
+                            }
+                            MatchState::Match(start_point) => {
+                                hyperlink_match = start_point..=prev_input_point;
+                                MatchState::Done
+                            }
+                            MatchState::Done => {
+                                panic!("Extra '‹', '›'")
+                            }
+                        }
+                    }
+                    _ => {
+                        if let CapturesState::Row(number) | CapturesState::Column(number) =
+                            &mut captures_state
+                        {
+                            number.push(c)
+                        }
+
+                        let is_windows_abs_path_start = captures_state
+                            == CapturesState::PathNextChar
+                            && cfg!(windows)
+                            && hyperlink_kind == HyperlinkKind::Path
+                            && c == '\\'
+                            && chars.peek().is_some_and(|c| *c != '\\');
+
+                        if is_windows_abs_path_start {
+                            // Convert Unix abs path start into Windows abs path start so that the
+                            // same test can be used for both OSes.
+                            term.input('C');
+                            prev_input_point = prev_input_point_from_term(&term);
+                            term.input(':');
+                            term.input(c);
+                        } else {
+                            term.input(c);
+                            prev_input_point = prev_input_point_from_term(&term);
+                        }
+
+                        if hovered_state == HoveredState::HoveredNextChar {
+                            hovered_grid_point = Some(prev_input_point);
+                            hovered_state = HoveredState::Done;
+                        }
+                        if captures_state == CapturesState::PathNextChar {
+                            captures_state = CapturesState::Path(prev_input_point);
+                        }
+                        if match_state == MatchState::MatchNextChar {
+                            match_state = MatchState::Match(prev_input_point);
+                        }
+                    }
+                }
+            }
+            term.move_down_and_cr(1);
+        }
+
+        if hyperlink_kind == HyperlinkKind::FileIri {
+            let Ok(url) = Url::parse(&iri_or_path) else {
+                panic!("Failed to parse file IRI `{iri_or_path}`");
+            };
+            let Ok(path) = url.to_file_path() else {
+                panic!("Failed to interpret file IRI `{iri_or_path}` as a path");
+            };
+            iri_or_path = path.to_string_lossy().to_string();
+        }
+
+        if cfg!(windows) {
+            // Handle verbatim and UNC paths for Windows
+            if let Some(stripped) = iri_or_path.strip_prefix(r#"\\?\UNC\"#) {
+                iri_or_path = format!(r#"\\{stripped}"#);
+            } else if let Some(stripped) = iri_or_path.strip_prefix(r#"\\?\"#) {
+                iri_or_path = stripped.to_string();
+            }
+        }
+
+        let hovered_grid_point = hovered_grid_point.expect("Missing hovered point (👉 or 👈)");
+        let hovered_char = term.grid().index(hovered_grid_point).c;
+        (
+            term,
+            ExpectedHyperlink {
+                hovered_grid_point,
+                hovered_char,
+                hyperlink_kind,
+                iri_or_path,
+                row,
+                column,
+                hyperlink_match,
+            },
+        )
+    }
+
+    fn line_cells_count(line: &str) -> usize {
+        // This avoids taking a dependency on the unicode-width crate
+        fn width(c: char) -> usize {
+            match c {
+                // Fullwidth unicode characters used in tests
+                '例' | '🏃' | '🦀' | '🔥' => 2,
+                _ => 1,
+            }
+        }
+        const CONTROL_CHARS: &str = "‹«👉👈»›";
+        line.chars()
+            .filter(|c| !CONTROL_CHARS.contains(*c))
+            .map(width)
+            .sum::<usize>()
+    }
+
+    struct CheckHyperlinkMatch<'a> {
+        term: &'a Term<VoidListener>,
+        expected_hyperlink: &'a ExpectedHyperlink,
+        source_location: &'a str,
+    }
+
+    impl<'a> CheckHyperlinkMatch<'a> {
+        fn new(
+            term: &'a Term<VoidListener>,
+            expected_hyperlink: &'a ExpectedHyperlink,
+            source_location: &'a str,
+        ) -> Self {
+            Self {
+                term,
+                expected_hyperlink,
+                source_location,
+            }
+        }
+
+        fn check_path_with_position_and_match(
+            &self,
+            path_with_position: PathWithPosition,
+            hyperlink_match: &Match,
+        ) {
+            let format_path_with_position_and_match =
+                |path_with_position: &PathWithPosition, hyperlink_match: &Match| {
+                    let mut result =
+                        format!("Path = «{}»", &path_with_position.path.to_string_lossy());
+                    if let Some(row) = path_with_position.row {
+                        result += &format!(", line = {row}");
+                        if let Some(column) = path_with_position.column {
+                            result += &format!(", column = {column}");
+                        }
+                    }
+
+                    result += &format!(
+                        ", at grid cells {}",
+                        Self::format_hyperlink_match(hyperlink_match)
+                    );
+                    result
+                };
+
+            assert_ne!(
+                self.expected_hyperlink.hyperlink_kind,
+                HyperlinkKind::Iri,
+                "\n    at {}\nExpected a path, but was a iri:\n{}",
+                self.source_location,
+                self.format_renderable_content()
+            );
+
+            assert_eq!(
+                format_path_with_position_and_match(
+                    &PathWithPosition {
+                        path: PathBuf::from(self.expected_hyperlink.iri_or_path.clone()),
+                        row: self.expected_hyperlink.row,
+                        column: self.expected_hyperlink.column
+                    },
+                    &self.expected_hyperlink.hyperlink_match
+                ),
+                format_path_with_position_and_match(&path_with_position, hyperlink_match),
+                "\n    at {}:\n{}",
+                self.source_location,
+                self.format_renderable_content()
+            );
+        }
+
+        fn check_iri_and_match(&self, iri: String, hyperlink_match: &Match) {
+            let format_iri_and_match = |iri: &String, hyperlink_match: &Match| {
+                format!(
+                    "Url = «{iri}», at grid cells {}",
+                    Self::format_hyperlink_match(hyperlink_match)
+                )
+            };
+
+            assert_eq!(
+                self.expected_hyperlink.hyperlink_kind,
+                HyperlinkKind::Iri,
+                "\n    at {}\nExpected a iri, but was a path:\n{}",
+                self.source_location,
+                self.format_renderable_content()
+            );
+
+            assert_eq!(
+                format_iri_and_match(
+                    &self.expected_hyperlink.iri_or_path,
+                    &self.expected_hyperlink.hyperlink_match
+                ),
+                format_iri_and_match(&iri, hyperlink_match),
+                "\n    at {}:\n{}",
+                self.source_location,
+                self.format_renderable_content()
+            );
+        }
+
+        fn format_hyperlink_match(hyperlink_match: &Match) -> String {
+            format!(
+                "({}, {})..=({}, {})",
+                hyperlink_match.start().line.0,
+                hyperlink_match.start().column.0,
+                hyperlink_match.end().line.0,
+                hyperlink_match.end().column.0
+            )
+        }
+
+        fn format_renderable_content(&self) -> String {
+            let mut result = format!("\nHovered on '{}'\n", self.expected_hyperlink.hovered_char);
+
+            let mut first_header_row = String::new();
+            let mut second_header_row = String::new();
+            let mut marker_header_row = String::new();
+            for index in 0..self.term.columns() {
+                let remainder = index % 10;
+                first_header_row.push_str(
+                    &(index > 0 && remainder == 0)
+                        .then_some((index / 10).to_string())
+                        .unwrap_or(" ".into()),
+                );
+                second_header_row += &remainder.to_string();
+                if index == self.expected_hyperlink.hovered_grid_point.column.0 {
+                    marker_header_row.push('↓');
+                } else {
+                    marker_header_row.push(' ');
+                }
+            }
+
+            result += &format!("\n      [{}]\n", first_header_row);
+            result += &format!("      [{}]\n", second_header_row);
+            result += &format!("       {}", marker_header_row);
+
+            let spacers: Flags = Flags::LEADING_WIDE_CHAR_SPACER | Flags::WIDE_CHAR_SPACER;
+            for cell in self
+                .term
+                .renderable_content()
+                .display_iter
+                .filter(|cell| !cell.flags.intersects(spacers))
+            {
+                if cell.point.column.0 == 0 {
+                    let prefix =
+                        if cell.point.line == self.expected_hyperlink.hovered_grid_point.line {
+                            '→'
+                        } else {
+                            ' '
+                        };
+                    result += &format!("\n{prefix}[{:>3}] ", cell.point.line.to_string());
+                }
+
+                result.push(cell.c);
+            }
+
+            result
+        }
+    }
+
+    fn test_hyperlink<'a>(
+        columns: usize,
+        total_cells: usize,
+        test_lines: impl Iterator<Item = &'a str>,
+        hyperlink_kind: HyperlinkKind,
+        source_location: &str,
+    ) {
+        thread_local! {
+            static TEST_REGEX_SEARCHES: RefCell<RegexSearches> = RefCell::new(RegexSearches::new());
+        }
+
+        let term_size = TermSize::new(columns, total_cells / columns + 2);
+        let (term, expected_hyperlink) =
+            build_term_from_test_lines(hyperlink_kind, term_size, test_lines);
+        let hyperlink_found = TEST_REGEX_SEARCHES.with(|regex_searches| {
+            find_from_grid_point(
+                &term,
+                expected_hyperlink.hovered_grid_point,
+                &mut regex_searches.borrow_mut(),
+            )
+        });
+        let check_hyperlink_match =
+            CheckHyperlinkMatch::new(&term, &expected_hyperlink, source_location);
+        match hyperlink_found {
+            Some((hyperlink_word, false, hyperlink_match)) => {
+                check_hyperlink_match.check_path_with_position_and_match(
+                    PathWithPosition::parse_str(&hyperlink_word),
+                    &hyperlink_match,
+                );
+            }
+            Some((hyperlink_word, true, hyperlink_match)) => {
+                check_hyperlink_match.check_iri_and_match(hyperlink_word, &hyperlink_match);
+            }
+            _ => {
+                assert!(
+                    false,
+                    "No hyperlink found\n     at {source_location}:\n{}",
+                    check_hyperlink_match.format_renderable_content()
+                )
+            }
+        }
+    }
+}
diff --git a/crates/terminal/src/terminal_settings.rs b/crates/terminal/src/terminal_settings.rs
index c3051e089c68e3df0733c9e6cf7c8a42f56e742d..0ab92a0f26d35710da7fd0a2e88542a98c7affed 100644
--- a/crates/terminal/src/terminal_settings.rs
+++ b/crates/terminal/src/terminal_settings.rs
@@ -6,7 +6,7 @@ use gpui::{AbsoluteLength, App, FontFallbacks, FontFeatures, FontWeight, Pixels,
 use schemars::JsonSchema;
 use serde_derive::{Deserialize, Serialize};
 
-use settings::{SettingsSources, SettingsUi};
+use settings::{SettingsKey, SettingsSources, SettingsUi};
 use std::path::PathBuf;
 use task::Shell;
 use theme::FontFamilyName;
@@ -135,7 +135,8 @@ pub enum ActivateScript {
     Pyenv,
 }
 
-#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema, SettingsUi)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey)]
+#[settings_key(key = "terminal")]
 pub struct TerminalSettingsContent {
     /// What shell to use when opening a terminal.
     ///
@@ -253,8 +254,6 @@ pub struct TerminalSettingsContent {
 }
 
 impl settings::Settings for TerminalSettings {
-    const KEY: Option<&'static str> = Some("terminal");
-
     type FileContent = TerminalSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> anyhow::Result<Self> {
diff --git a/crates/terminal_view/src/terminal_element.rs b/crates/terminal_view/src/terminal_element.rs
index 5bbf5ad36b3de89514d92ce9e305988817cec32f..a786aa20e60f28b1f22bd1c9e8d993098aa96de4 100644
--- a/crates/terminal_view/src/terminal_element.rs
+++ b/crates/terminal_view/src/terminal_element.rs
@@ -1192,8 +1192,8 @@ impl Element for TerminalElement {
                 bounds.origin + Point::new(layout.gutter, px(0.)) - Point::new(px(0.), scroll_top);
 
             let marked_text_cloned: Option<String> = {
-                let ime_state = self.terminal_view.read(cx);
-                ime_state.marked_text.clone()
+                let ime_state = &self.terminal_view.read(cx).ime_state;
+                ime_state.as_ref().map(|state| state.marked_text.clone())
             };
 
             let terminal_input_handler = TerminalInputHandler {
@@ -1421,11 +1421,9 @@ impl InputHandler for TerminalInputHandler {
         _window: &mut Window,
         cx: &mut App,
     ) {
-        if let Some(range) = new_marked_range {
-            self.terminal_view.update(cx, |view, view_cx| {
-                view.set_marked_text(new_text.to_string(), range, view_cx);
-            });
-        }
+        self.terminal_view.update(cx, |view, view_cx| {
+            view.set_marked_text(new_text.to_string(), new_marked_range, view_cx);
+        });
     }
 
     fn unmark_text(&mut self, _window: &mut Window, cx: &mut App) {
diff --git a/crates/terminal_view/src/terminal_panel.rs b/crates/terminal_view/src/terminal_panel.rs
index 2ba7f617bf407299b2b0e670f66432ce053718be..44d64c5fe3351d4c3e2a9342bfaf818445d78736 100644
--- a/crates/terminal_view/src/terminal_panel.rs
+++ b/crates/terminal_view/src/terminal_panel.rs
@@ -49,6 +49,8 @@ const TERMINAL_PANEL_KEY: &str = "TerminalPanel";
 actions!(
     terminal_panel,
     [
+        /// Toggles the terminal panel.
+        Toggle,
         /// Toggles focus on the terminal panel.
         ToggleFocus
     ]
@@ -64,6 +66,13 @@ pub fn init(cx: &mut App) {
                     workspace.toggle_panel_focus::<TerminalPanel>(window, cx);
                 }
             });
+            workspace.register_action(|workspace, _: &Toggle, window, cx| {
+                if is_enabled_in_workspace(workspace, cx) {
+                    if !workspace.toggle_panel_focus::<TerminalPanel>(window, cx) {
+                        workspace.close_panel::<TerminalPanel>(window, cx);
+                    }
+                }
+            });
         },
     )
     .detach();
diff --git a/crates/terminal_view/src/terminal_view.rs b/crates/terminal_view/src/terminal_view.rs
index 2548a7c24460be3161147b69e30c6191ba5dd2e6..08caf9a4ef1c0b49dbfa8f8f2578f00ddb130ee0 100644
--- a/crates/terminal_view/src/terminal_view.rs
+++ b/crates/terminal_view/src/terminal_view.rs
@@ -62,6 +62,11 @@ use std::{
     time::Duration,
 };
 
+struct ImeState {
+    marked_text: String,
+    marked_range_utf16: Option<Range<usize>>,
+}
+
 const CURSOR_BLINK_INTERVAL: Duration = Duration::from_millis(500);
 const TERMINAL_SCROLLBAR_WIDTH: Pixels = px(12.);
 
@@ -138,8 +143,7 @@ pub struct TerminalView {
     scroll_handle: TerminalScrollHandle,
     show_scrollbar: bool,
     hide_scrollbar_task: Option<Task<()>>,
-    marked_text: Option<String>,
-    marked_range_utf16: Option<Range<usize>>,
+    ime_state: Option<ImeState>,
     _subscriptions: Vec<Subscription>,
     _terminal_subscriptions: Vec<Subscription>,
 }
@@ -263,8 +267,7 @@ impl TerminalView {
             show_scrollbar: !Self::should_autohide_scrollbar(cx),
             hide_scrollbar_task: None,
             cwd_serialized: false,
-            marked_text: None,
-            marked_range_utf16: None,
+            ime_state: None,
             _subscriptions: vec![
                 focus_in,
                 focus_out,
@@ -323,24 +326,27 @@ impl TerminalView {
     pub(crate) fn set_marked_text(
         &mut self,
         text: String,
-        range: Range<usize>,
+        range: Option<Range<usize>>,
         cx: &mut Context<Self>,
     ) {
-        self.marked_text = Some(text);
-        self.marked_range_utf16 = Some(range);
+        self.ime_state = Some(ImeState {
+            marked_text: text,
+            marked_range_utf16: range,
+        });
         cx.notify();
     }
 
     /// Gets the current marked range (UTF-16).
     pub(crate) fn marked_text_range(&self) -> Option<Range<usize>> {
-        self.marked_range_utf16.clone()
+        self.ime_state
+            .as_ref()
+            .and_then(|state| state.marked_range_utf16.clone())
     }
 
     /// Clears the marked (pre-edit) text state.
     pub(crate) fn clear_marked_text(&mut self, cx: &mut Context<Self>) {
-        if self.marked_text.is_some() {
-            self.marked_text = None;
-            self.marked_range_utf16 = None;
+        if self.ime_state.is_some() {
+            self.ime_state = None;
             cx.notify();
         }
     }
diff --git a/crates/text/src/locator.rs b/crates/text/src/locator.rs
index d529e60d48ed520b518ed9beee789860eb84860a..9b89cf21c74eccfe6cbb93fd2dec5bc849f2170d 100644
--- a/crates/text/src/locator.rs
+++ b/crates/text/src/locator.rs
@@ -106,13 +106,13 @@ mod tests {
         let mut rhs = Default::default();
         while lhs == rhs {
             lhs = Locator(
-                (0..rng.gen_range(1..=5))
-                    .map(|_| rng.gen_range(0..=100))
+                (0..rng.random_range(1..=5))
+                    .map(|_| rng.random_range(0..=100))
                     .collect(),
             );
             rhs = Locator(
-                (0..rng.gen_range(1..=5))
-                    .map(|_| rng.gen_range(0..=100))
+                (0..rng.random_range(1..=5))
+                    .map(|_| rng.random_range(0..=100))
                     .collect(),
             );
         }
diff --git a/crates/text/src/network.rs b/crates/text/src/network.rs
index f22bb52d205ba9505d9f2dc168628734346d81f5..d0d1b650ad92f8ab258cdd37e2bfc662855d6a97 100644
--- a/crates/text/src/network.rs
+++ b/crates/text/src/network.rs
@@ -65,8 +65,8 @@ impl<T: Clone, R: rand::Rng> Network<T, R> {
                 for message in &messages {
                     // Insert one or more duplicates of this message, potentially *before* the previous
                     // message sent by this peer to simulate out-of-order delivery.
-                    for _ in 0..self.rng.gen_range(1..4) {
-                        let insertion_index = self.rng.gen_range(0..inbox.len() + 1);
+                    for _ in 0..self.rng.random_range(1..4) {
+                        let insertion_index = self.rng.random_range(0..inbox.len() + 1);
                         inbox.insert(
                             insertion_index,
                             Envelope {
@@ -85,7 +85,7 @@ impl<T: Clone, R: rand::Rng> Network<T, R> {
 
     pub fn receive(&mut self, receiver: ReplicaId) -> Vec<T> {
         let inbox = self.inboxes.get_mut(&receiver).unwrap();
-        let count = self.rng.gen_range(0..inbox.len() + 1);
+        let count = self.rng.random_range(0..inbox.len() + 1);
         inbox
             .drain(0..count)
             .map(|envelope| envelope.message)
diff --git a/crates/text/src/patch.rs b/crates/text/src/patch.rs
index dcb35e9a921538134b94e2870011eb3b341f01de..b8bb904052be44d7b67ba51215896f6f308c39c9 100644
--- a/crates/text/src/patch.rs
+++ b/crates/text/src/patch.rs
@@ -497,8 +497,8 @@ mod tests {
             .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
             .unwrap_or(20);
 
-        let initial_chars = (0..rng.gen_range(0..=100))
-            .map(|_| rng.gen_range(b'a'..=b'z') as char)
+        let initial_chars = (0..rng.random_range(0..=100))
+            .map(|_| rng.random_range(b'a'..=b'z') as char)
             .collect::<Vec<_>>();
         log::info!("initial chars: {:?}", initial_chars);
 
@@ -517,11 +517,11 @@ mod tests {
                     break;
                 }
 
-                let end = rng.gen_range(last_edit_end..=expected_chars.len());
-                let start = rng.gen_range(last_edit_end..=end);
+                let end = rng.random_range(last_edit_end..=expected_chars.len());
+                let start = rng.random_range(last_edit_end..=end);
                 let old_len = end - start;
 
-                let mut new_len = rng.gen_range(0..=3);
+                let mut new_len = rng.random_range(0..=3);
                 if start == end && new_len == 0 {
                     new_len += 1;
                 }
@@ -529,7 +529,7 @@ mod tests {
                 last_edit_end = start + new_len + 1;
 
                 let new_chars = (0..new_len)
-                    .map(|_| rng.gen_range(b'A'..=b'Z') as char)
+                    .map(|_| rng.random_range(b'A'..=b'Z') as char)
                     .collect::<Vec<_>>();
                 log::info!(
                     "  editing {:?}: {:?}",
diff --git a/crates/text/src/tests.rs b/crates/text/src/tests.rs
index a096f1281f592babf7900891a6412451bdc362d0..4298e704ab5f8fbe57af363379395ef23624cfcf 100644
--- a/crates/text/src/tests.rs
+++ b/crates/text/src/tests.rs
@@ -36,14 +36,14 @@ fn test_random_edits(mut rng: StdRng) {
         .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
         .unwrap_or(10);
 
-    let reference_string_len = rng.gen_range(0..3);
+    let reference_string_len = rng.random_range(0..3);
     let mut reference_string = RandomCharIter::new(&mut rng)
         .take(reference_string_len)
         .collect::<String>();
     let mut buffer = Buffer::new(0, BufferId::new(1).unwrap(), reference_string.clone());
     LineEnding::normalize(&mut reference_string);
 
-    buffer.set_group_interval(Duration::from_millis(rng.gen_range(0..=200)));
+    buffer.set_group_interval(Duration::from_millis(rng.random_range(0..=200)));
     let mut buffer_versions = Vec::new();
     log::info!(
         "buffer text {:?}, version: {:?}",
@@ -64,7 +64,7 @@ fn test_random_edits(mut rng: StdRng) {
             buffer.version()
         );
 
-        if rng.gen_bool(0.25) {
+        if rng.random_bool(0.25) {
             buffer.randomly_undo_redo(&mut rng);
             reference_string = buffer.text();
             log::info!(
@@ -82,7 +82,7 @@ fn test_random_edits(mut rng: StdRng) {
 
         buffer.check_invariants();
 
-        if rng.gen_bool(0.3) {
+        if rng.random_bool(0.3) {
             buffer_versions.push((buffer.clone(), buffer.subscribe()));
         }
     }
@@ -112,8 +112,9 @@ fn test_random_edits(mut rng: StdRng) {
         );
 
         for _ in 0..5 {
-            let end_ix = old_buffer.clip_offset(rng.gen_range(0..=old_buffer.len()), Bias::Right);
-            let start_ix = old_buffer.clip_offset(rng.gen_range(0..=end_ix), Bias::Left);
+            let end_ix =
+                old_buffer.clip_offset(rng.random_range(0..=old_buffer.len()), Bias::Right);
+            let start_ix = old_buffer.clip_offset(rng.random_range(0..=end_ix), Bias::Left);
             let range = old_buffer.anchor_before(start_ix)..old_buffer.anchor_after(end_ix);
             let mut old_text = old_buffer.text_for_range(range.clone()).collect::<String>();
             let edits = buffer
@@ -731,7 +732,7 @@ fn test_random_concurrent_edits(mut rng: StdRng) {
         .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
         .unwrap_or(10);
 
-    let base_text_len = rng.gen_range(0..10);
+    let base_text_len = rng.random_range(0..10);
     let base_text = RandomCharIter::new(&mut rng)
         .take(base_text_len)
         .collect::<String>();
@@ -741,7 +742,7 @@ fn test_random_concurrent_edits(mut rng: StdRng) {
 
     for i in 0..peers {
         let mut buffer = Buffer::new(i as ReplicaId, BufferId::new(1).unwrap(), base_text.clone());
-        buffer.history.group_interval = Duration::from_millis(rng.gen_range(0..=200));
+        buffer.history.group_interval = Duration::from_millis(rng.random_range(0..=200));
         buffers.push(buffer);
         replica_ids.push(i as u16);
         network.add_peer(i as u16);
@@ -751,10 +752,10 @@ fn test_random_concurrent_edits(mut rng: StdRng) {
 
     let mut mutation_count = operations;
     loop {
-        let replica_index = rng.gen_range(0..peers);
+        let replica_index = rng.random_range(0..peers);
         let replica_id = replica_ids[replica_index];
         let buffer = &mut buffers[replica_index];
-        match rng.gen_range(0..=100) {
+        match rng.random_range(0..=100) {
             0..=50 if mutation_count != 0 => {
                 let op = buffer.randomly_edit(&mut rng, 5).1;
                 network.broadcast(buffer.replica_id, vec![op]);
diff --git a/crates/text/src/text.rs b/crates/text/src/text.rs
index 705d3f1788288eb67a0b3b756ba545dc99b031d3..8fb6f56222b503360a3d2dd6f4a6b27d1ac728e3 100644
--- a/crates/text/src/text.rs
+++ b/crates/text/src/text.rs
@@ -1818,8 +1818,8 @@ impl Buffer {
     }
 
     pub fn random_byte_range(&self, start_offset: usize, rng: &mut impl rand::Rng) -> Range<usize> {
-        let end = self.clip_offset(rng.gen_range(start_offset..=self.len()), Bias::Right);
-        let start = self.clip_offset(rng.gen_range(start_offset..=end), Bias::Right);
+        let end = self.clip_offset(rng.random_range(start_offset..=self.len()), Bias::Right);
+        let start = self.clip_offset(rng.random_range(start_offset..=end), Bias::Right);
         start..end
     }
 
@@ -1841,7 +1841,7 @@ impl Buffer {
             let range = self.random_byte_range(new_start, rng);
             last_end = Some(range.end);
 
-            let new_text_len = rng.gen_range(0..10);
+            let new_text_len = rng.random_range(0..10);
             let new_text: String = RandomCharIter::new(&mut *rng).take(new_text_len).collect();
 
             edits.push((range, new_text.into()));
@@ -1877,7 +1877,7 @@ impl Buffer {
         use rand::prelude::*;
 
         let mut ops = Vec::new();
-        for _ in 0..rng.gen_range(1..=5) {
+        for _ in 0..rng.random_range(1..=5) {
             if let Some(entry) = self.history.undo_stack.choose(rng) {
                 let transaction = entry.transaction.clone();
                 log::info!(
diff --git a/crates/theme/src/font_family_cache.rs b/crates/theme/src/font_family_cache.rs
index fecaf5b360a91beca3fceb564c87973d6f676384..411cf9b4d41359f4da4520061ac46c984bdd08f2 100644
--- a/crates/theme/src/font_family_cache.rs
+++ b/crates/theme/src/font_family_cache.rs
@@ -16,7 +16,7 @@ struct FontFamilyCacheState {
 /// so we do it once and then use the cached values each render.
 #[derive(Default)]
 pub struct FontFamilyCache {
-    state: RwLock<FontFamilyCacheState>,
+    state: Arc<RwLock<FontFamilyCacheState>>,
 }
 
 #[derive(Default)]
@@ -52,4 +52,44 @@ impl FontFamilyCache {
 
         lock.font_families.clone()
     }
+
+    /// Returns the list of font families if they have been loaded
+    pub fn try_list_font_families(&self) -> Option<Vec<SharedString>> {
+        self.state
+            .try_read()
+            .filter(|state| state.loaded_at.is_some())
+            .map(|state| state.font_families.clone())
+    }
+
+    /// Prefetch all font names in the background
+    pub async fn prefetch(&self, cx: &gpui::AsyncApp) {
+        if self
+            .state
+            .try_read()
+            .is_none_or(|state| state.loaded_at.is_some())
+        {
+            return;
+        }
+
+        let Ok(text_system) = cx.update(|cx| App::text_system(cx).clone()) else {
+            return;
+        };
+
+        let state = self.state.clone();
+
+        cx.background_executor()
+            .spawn(async move {
+                // We take this lock in the background executor to ensure that synchronous calls to `list_font_families` are blocked while we are prefetching,
+                // while not blocking the main thread and risking deadlocks
+                let mut lock = state.write();
+                let all_font_names = text_system
+                    .all_font_names()
+                    .into_iter()
+                    .map(SharedString::from)
+                    .collect();
+                lock.font_families = all_font_names;
+                lock.loaded_at = Some(Instant::now());
+            })
+            .await;
+    }
 }
diff --git a/crates/theme/src/settings.rs b/crates/theme/src/settings.rs
index 11db22d97485f5d400abdd8638da501abd55a192..8409c60b22b03b8d917b84ae20229dc2db63fe4a 100644
--- a/crates/theme/src/settings.rs
+++ b/crates/theme/src/settings.rs
@@ -13,7 +13,7 @@ use gpui::{
 use refineable::Refineable;
 use schemars::{JsonSchema, json_schema};
 use serde::{Deserialize, Serialize};
-use settings::{ParameterizedJsonSchema, Settings, SettingsSources, SettingsUi};
+use settings::{ParameterizedJsonSchema, Settings, SettingsKey, SettingsSources, SettingsUi};
 use std::sync::Arc;
 use util::ResultExt as _;
 use util::schemars::replace_subschema;
@@ -253,8 +253,9 @@ pub(crate) struct UiFontSize(Pixels);
 
 impl Global for UiFontSize {}
 
+/// In-memory override for the font size in the agent panel.
 #[derive(Default)]
-pub(crate) struct AgentFontSize(Pixels);
+pub struct AgentFontSize(Pixels);
 
 impl Global for AgentFontSize {}
 
@@ -365,7 +366,8 @@ impl IconThemeSelection {
 }
 
 /// Settings for rendering text in UI and text buffers.
-#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema, SettingsUi)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey)]
+#[settings_key(None)]
 pub struct ThemeSettingsContent {
     /// The default font size for text in the UI.
     #[serde(default)]
@@ -817,8 +819,6 @@ fn clamp_font_weight(weight: f32) -> FontWeight {
 }
 
 impl settings::Settings for ThemeSettings {
-    const KEY: Option<&'static str> = None;
-
     type FileContent = ThemeSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, cx: &mut App) -> Result<Self> {
diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs
index f031b8394afc551c8077419f504104936095a0c3..e15e7ad46dd18c41a1c15fa927352b44184530f7 100644
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -660,8 +660,12 @@ impl TitleBar {
 
                         let (plan_name, label_color, bg_color) = match plan {
                             None | Some(Plan::ZedFree) => ("Free", Color::Default, free_chip_bg),
-                            Some(Plan::ZedProTrial) => ("Pro Trial", Color::Accent, pro_chip_bg),
-                            Some(Plan::ZedPro) => ("Pro", Color::Accent, pro_chip_bg),
+                            Some(Plan::ZedProTrial | Plan::ZedProTrialV2) => {
+                                ("Pro Trial", Color::Accent, pro_chip_bg)
+                            }
+                            Some(Plan::ZedPro | Plan::ZedProV2) => {
+                                ("Pro", Color::Accent, pro_chip_bg)
+                            }
                         };
 
                         menu.custom_entry(
@@ -689,7 +693,7 @@ impl TitleBar {
                             "Settings Profiles",
                             zed_actions::settings_profile_selector::Toggle.boxed_clone(),
                         )
-                        .action("Key Bindings", Box::new(keymap_editor::OpenKeymapEditor))
+                        .action("Keymap Editor", Box::new(keymap_editor::OpenKeymapEditor))
                         .action(
                             "Themes…",
                             zed_actions::theme_selector::Toggle::default().boxed_clone(),
diff --git a/crates/title_bar/src/title_bar_settings.rs b/crates/title_bar/src/title_bar_settings.rs
index 0dc301f7eef6789bf1c0a2ad51cb63dff77d0337..38e529098bd3e97a11ecefac684c1734302f4261 100644
--- a/crates/title_bar/src/title_bar_settings.rs
+++ b/crates/title_bar/src/title_bar_settings.rs
@@ -1,7 +1,7 @@
 use db::anyhow;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 
 #[derive(Copy, Clone, Deserialize, Debug)]
 pub struct TitleBarSettings {
@@ -14,8 +14,11 @@ pub struct TitleBarSettings {
     pub show_menus: bool,
 }
 
-#[derive(Copy, Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi)]
-#[settings_ui(group = "Title Bar", path = "title_bar")]
+#[derive(
+    Copy, Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi, SettingsKey,
+)]
+#[settings_ui(group = "Title Bar")]
+#[settings_key(key = "title_bar")]
 pub struct TitleBarSettingsContent {
     /// Whether to show the branch icon beside branch switcher in the title bar.
     ///
@@ -48,8 +51,6 @@ pub struct TitleBarSettingsContent {
 }
 
 impl Settings for TitleBarSettings {
-    const KEY: Option<&'static str> = Some("title_bar");
-
     type FileContent = TitleBarSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut gpui::App) -> anyhow::Result<Self>
diff --git a/crates/toolchain_selector/Cargo.toml b/crates/toolchain_selector/Cargo.toml
index 46b88594fdda8979a861fb33317cae81a32d2ea1..a17f82564093e2ae17f95ec82559f308b910b2dd 100644
--- a/crates/toolchain_selector/Cargo.toml
+++ b/crates/toolchain_selector/Cargo.toml
@@ -6,10 +6,15 @@ publish.workspace = true
 license = "GPL-3.0-or-later"
 
 [dependencies]
+anyhow.workspace = true
+convert_case.workspace = true
 editor.workspace = true
+file_finder.workspace = true
+futures.workspace = true
 fuzzy.workspace = true
 gpui.workspace = true
 language.workspace = true
+menu.workspace = true
 picker.workspace = true
 project.workspace = true
 ui.workspace = true
diff --git a/crates/toolchain_selector/src/active_toolchain.rs b/crates/toolchain_selector/src/active_toolchain.rs
index bf45bffea30791a062e4a130b0f742f3d47c1342..3e26f3ad6c3d23c4b0e00c4c9f67e37fd9c33d32 100644
--- a/crates/toolchain_selector/src/active_toolchain.rs
+++ b/crates/toolchain_selector/src/active_toolchain.rs
@@ -5,8 +5,8 @@ use gpui::{
     AsyncWindowContext, Context, Entity, IntoElement, ParentElement, Render, Subscription, Task,
     WeakEntity, Window, div,
 };
-use language::{Buffer, BufferEvent, LanguageName, Toolchain};
-use project::{Project, ProjectPath, WorktreeId, toolchain_store::ToolchainStoreEvent};
+use language::{Buffer, BufferEvent, LanguageName, Toolchain, ToolchainScope};
+use project::{Project, ProjectPath, Toolchains, WorktreeId, toolchain_store::ToolchainStoreEvent};
 use ui::{Button, ButtonCommon, Clickable, FluentBuilder, LabelSize, SharedString, Tooltip};
 use util::maybe;
 use workspace::{StatusItemView, Workspace, item::ItemHandle};
@@ -69,15 +69,15 @@ impl ActiveToolchain {
                     .read_with(cx, |this, _| Some(this.language()?.name()))
                     .ok()
                     .flatten()?;
-                let term = workspace
+                let meta = workspace
                     .update(cx, |workspace, cx| {
                         let languages = workspace.project().read(cx).languages();
-                        Project::toolchain_term(languages.clone(), language_name.clone())
+                        Project::toolchain_metadata(languages.clone(), language_name.clone())
                     })
                     .ok()?
                     .await?;
                 let _ = this.update(cx, |this, cx| {
-                    this.term = term;
+                    this.term = meta.term;
                     cx.notify();
                 });
                 let (worktree_id, path) = active_file
@@ -170,7 +170,11 @@ impl ActiveToolchain {
                 let project = workspace
                     .read_with(cx, |this, _| this.project().clone())
                     .ok()?;
-                let (toolchains, relative_path) = cx
+                let Toolchains {
+                    toolchains,
+                    root_path: relative_path,
+                    user_toolchains,
+                } = cx
                     .update(|_, cx| {
                         project.read(cx).available_toolchains(
                             ProjectPath {
@@ -183,8 +187,20 @@ impl ActiveToolchain {
                     })
                     .ok()?
                     .await?;
-                if let Some(toolchain) = toolchains.toolchains.first() {
-                    // Since we don't have a selected toolchain, pick one for user here.
+                // Since we don't have a selected toolchain, pick one for user here.
+                let default_choice = user_toolchains
+                    .iter()
+                    .find_map(|(scope, toolchains)| {
+                        if scope == &ToolchainScope::Global {
+                            // Ignore global toolchains when making a default choice. They're unlikely to be the right choice.
+                            None
+                        } else {
+                            toolchains.first()
+                        }
+                    })
+                    .or_else(|| toolchains.toolchains.first())
+                    .cloned();
+                if let Some(toolchain) = &default_choice {
                     workspace::WORKSPACE_DB
                         .set_toolchain(
                             workspace_id,
@@ -209,7 +225,7 @@ impl ActiveToolchain {
                         .await;
                 }
 
-                toolchains.toolchains.first().cloned()
+                default_choice
             }
         })
     }
diff --git a/crates/toolchain_selector/src/toolchain_selector.rs b/crates/toolchain_selector/src/toolchain_selector.rs
index feeca8cf52a5116d53562826da72a0bb304d16ce..2f946a69152f76912a1da996e429c48e3ec3be10 100644
--- a/crates/toolchain_selector/src/toolchain_selector.rs
+++ b/crates/toolchain_selector/src/toolchain_selector.rs
@@ -1,25 +1,39 @@
 mod active_toolchain;
 
 pub use active_toolchain::ActiveToolchain;
+use convert_case::Casing as _;
 use editor::Editor;
+use file_finder::OpenPathDelegate;
+use futures::channel::oneshot;
 use fuzzy::{StringMatch, StringMatchCandidate, match_strings};
 use gpui::{
-    App, Context, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, ParentElement,
-    Render, Styled, Task, WeakEntity, Window, actions,
+    Action, Animation, AnimationExt, App, Context, DismissEvent, Entity, EventEmitter, FocusHandle,
+    Focusable, KeyContext, ParentElement, Render, Styled, Subscription, Task, WeakEntity, Window,
+    actions, pulsating_between,
 };
-use language::{LanguageName, Toolchain, ToolchainList};
+use language::{Language, LanguageName, Toolchain, ToolchainScope};
 use picker::{Picker, PickerDelegate};
-use project::{Project, ProjectPath, WorktreeId};
-use std::{borrow::Cow, path::Path, sync::Arc};
-use ui::{HighlightedLabel, ListItem, ListItemSpacing, prelude::*};
-use util::ResultExt;
+use project::{DirectoryLister, Project, ProjectPath, Toolchains, WorktreeId};
+use std::{
+    borrow::Cow,
+    path::{Path, PathBuf},
+    sync::Arc,
+    time::Duration,
+};
+use ui::{
+    Divider, HighlightedLabel, KeyBinding, List, ListItem, ListItemSpacing, Navigable,
+    NavigableEntry, prelude::*,
+};
+use util::{ResultExt, maybe, paths::PathStyle};
 use workspace::{ModalView, Workspace};
 
 actions!(
     toolchain,
     [
         /// Selects a toolchain for the current project.
-        Select
+        Select,
+        /// Adds a new toolchain for the current project.
+        AddToolchain
     ]
 );
 
@@ -28,9 +42,513 @@ pub fn init(cx: &mut App) {
 }
 
 pub struct ToolchainSelector {
+    state: State,
+    create_search_state: Arc<dyn Fn(&mut Window, &mut Context<Self>) -> SearchState + 'static>,
+    language: Option<Arc<Language>>,
+    project: Entity<Project>,
+    language_name: LanguageName,
+    worktree_id: WorktreeId,
+    relative_path: Arc<Path>,
+}
+
+#[derive(Clone)]
+struct SearchState {
     picker: Entity<Picker<ToolchainSelectorDelegate>>,
 }
 
+struct AddToolchainState {
+    state: AddState,
+    project: Entity<Project>,
+    language_name: LanguageName,
+    root_path: ProjectPath,
+    weak: WeakEntity<ToolchainSelector>,
+}
+
+struct ScopePickerState {
+    entries: [NavigableEntry; 3],
+    selected_scope: ToolchainScope,
+}
+
+#[expect(
+    dead_code,
+    reason = "These tasks have to be kept alive to run to completion"
+)]
+enum PathInputState {
+    WaitingForPath(Task<()>),
+    Resolving(Task<()>),
+}
+
+enum AddState {
+    Path {
+        picker: Entity<Picker<file_finder::OpenPathDelegate>>,
+        error: Option<Arc<str>>,
+        input_state: PathInputState,
+        _subscription: Subscription,
+    },
+    Name {
+        toolchain: Toolchain,
+        editor: Entity<Editor>,
+        scope_picker: ScopePickerState,
+    },
+}
+
+impl AddToolchainState {
+    fn new(
+        project: Entity<Project>,
+        language_name: LanguageName,
+        root_path: ProjectPath,
+        window: &mut Window,
+        cx: &mut Context<ToolchainSelector>,
+    ) -> Entity<Self> {
+        let weak = cx.weak_entity();
+
+        cx.new(|cx| {
+            let (lister, rx) = Self::create_path_browser_delegate(project.clone(), cx);
+            let picker = cx.new(|cx| Picker::uniform_list(lister, window, cx));
+            Self {
+                state: AddState::Path {
+                    _subscription: cx.subscribe(&picker, |_, _, _: &DismissEvent, cx| {
+                        cx.stop_propagation();
+                    }),
+                    picker,
+                    error: None,
+                    input_state: Self::wait_for_path(rx, window, cx),
+                },
+                project,
+                language_name,
+                root_path,
+                weak,
+            }
+        })
+    }
+
+    fn create_path_browser_delegate(
+        project: Entity<Project>,
+        cx: &mut Context<Self>,
+    ) -> (OpenPathDelegate, oneshot::Receiver<Option<Vec<PathBuf>>>) {
+        let (tx, rx) = oneshot::channel();
+        let weak = cx.weak_entity();
+        let lister = OpenPathDelegate::new(
+            tx,
+            DirectoryLister::Project(project),
+            false,
+            PathStyle::current(),
+        )
+        .show_hidden()
+        .with_footer(Arc::new(move |_, cx| {
+            let error = weak
+                .read_with(cx, |this, _| {
+                    if let AddState::Path { error, .. } = &this.state {
+                        error.clone()
+                    } else {
+                        None
+                    }
+                })
+                .ok()
+                .flatten();
+            let is_loading = weak
+                .read_with(cx, |this, _| {
+                    matches!(
+                        this.state,
+                        AddState::Path {
+                            input_state: PathInputState::Resolving(_),
+                            ..
+                        }
+                    )
+                })
+                .unwrap_or_default();
+            Some(
+                v_flex()
+                    .child(Divider::horizontal())
+                    .child(
+                        h_flex()
+                            .p_1()
+                            .justify_between()
+                            .gap_2()
+                            .child(Label::new("Select Toolchain Path").color(Color::Muted).map(
+                                |this| {
+                                    if is_loading {
+                                        this.with_animation(
+                                            "select-toolchain-label",
+                                            Animation::new(Duration::from_secs(2))
+                                                .repeat()
+                                                .with_easing(pulsating_between(0.4, 0.8)),
+                                            |label, delta| label.alpha(delta),
+                                        )
+                                        .into_any()
+                                    } else {
+                                        this.into_any_element()
+                                    }
+                                },
+                            ))
+                            .when_some(error, |this, error| {
+                                this.child(Label::new(error).color(Color::Error))
+                            }),
+                    )
+                    .into_any(),
+            )
+        }));
+
+        (lister, rx)
+    }
+    fn resolve_path(
+        path: PathBuf,
+        root_path: ProjectPath,
+        language_name: LanguageName,
+        project: Entity<Project>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> PathInputState {
+        PathInputState::Resolving(cx.spawn_in(window, async move |this, cx| {
+            _ = maybe!(async move {
+                let toolchain = project
+                    .update(cx, |this, cx| {
+                        this.resolve_toolchain(path.clone(), language_name, cx)
+                    })?
+                    .await;
+                let Ok(toolchain) = toolchain else {
+                    // Go back to the path input state
+                    _ = this.update_in(cx, |this, window, cx| {
+                        if let AddState::Path {
+                            input_state,
+                            picker,
+                            error,
+                            ..
+                        } = &mut this.state
+                            && matches!(input_state, PathInputState::Resolving(_))
+                        {
+                            let Err(e) = toolchain else { unreachable!() };
+                            *error = Some(Arc::from(e.to_string()));
+                            let (delegate, rx) =
+                                Self::create_path_browser_delegate(this.project.clone(), cx);
+                            picker.update(cx, |picker, cx| {
+                                *picker = Picker::uniform_list(delegate, window, cx);
+                                picker.set_query(
+                                    Arc::from(path.to_string_lossy().as_ref()),
+                                    window,
+                                    cx,
+                                );
+                            });
+                            *input_state = Self::wait_for_path(rx, window, cx);
+                            this.focus_handle(cx).focus(window);
+                        }
+                    });
+                    return Err(anyhow::anyhow!("Failed to resolve toolchain"));
+                };
+                let resolved_toolchain_path = project.read_with(cx, |this, cx| {
+                    this.find_project_path(&toolchain.path.as_ref(), cx)
+                })?;
+
+                // Suggest a default scope based on the applicability.
+                let scope = if let Some(project_path) = resolved_toolchain_path {
+                    if root_path.path.as_ref() != Path::new("")
+                        && project_path.starts_with(&root_path)
+                    {
+                        ToolchainScope::Subproject(root_path.worktree_id, root_path.path)
+                    } else {
+                        ToolchainScope::Project
+                    }
+                } else {
+                    // This path lies outside of the project.
+                    ToolchainScope::Global
+                };
+
+                _ = this.update_in(cx, |this, window, cx| {
+                    let scope_picker = ScopePickerState {
+                        entries: std::array::from_fn(|_| NavigableEntry::focusable(cx)),
+                        selected_scope: scope,
+                    };
+                    this.state = AddState::Name {
+                        editor: cx.new(|cx| {
+                            let mut editor = Editor::single_line(window, cx);
+                            editor.set_text(toolchain.name.as_ref(), window, cx);
+                            editor
+                        }),
+                        toolchain,
+                        scope_picker,
+                    };
+                    this.focus_handle(cx).focus(window);
+                });
+
+                Result::<_, anyhow::Error>::Ok(())
+            })
+            .await;
+        }))
+    }
+
+    fn wait_for_path(
+        rx: oneshot::Receiver<Option<Vec<PathBuf>>>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> PathInputState {
+        let task = cx.spawn_in(window, async move |this, cx| {
+            maybe!(async move {
+                let result = rx.await.log_err()?;
+
+                let path = result
+                    .into_iter()
+                    .flat_map(|paths| paths.into_iter())
+                    .next()?;
+                this.update_in(cx, |this, window, cx| {
+                    if let AddState::Path {
+                        input_state, error, ..
+                    } = &mut this.state
+                        && matches!(input_state, PathInputState::WaitingForPath(_))
+                    {
+                        error.take();
+                        *input_state = Self::resolve_path(
+                            path,
+                            this.root_path.clone(),
+                            this.language_name.clone(),
+                            this.project.clone(),
+                            window,
+                            cx,
+                        );
+                    }
+                })
+                .ok()?;
+                Some(())
+            })
+            .await;
+        });
+        PathInputState::WaitingForPath(task)
+    }
+
+    fn confirm_toolchain(
+        &mut self,
+        _: &menu::Confirm,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let AddState::Name {
+            toolchain,
+            editor,
+            scope_picker,
+        } = &mut self.state
+        else {
+            return;
+        };
+
+        let text = editor.read(cx).text(cx);
+        if text.is_empty() {
+            return;
+        }
+
+        toolchain.name = SharedString::from(text);
+        self.project.update(cx, |this, cx| {
+            this.add_toolchain(toolchain.clone(), scope_picker.selected_scope.clone(), cx);
+        });
+        _ = self.weak.update(cx, |this, cx| {
+            this.state = State::Search((this.create_search_state)(window, cx));
+            this.focus_handle(cx).focus(window);
+            cx.notify();
+        });
+    }
+}
+impl Focusable for AddToolchainState {
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        match &self.state {
+            AddState::Path { picker, .. } => picker.focus_handle(cx),
+            AddState::Name { editor, .. } => editor.focus_handle(cx),
+        }
+    }
+}
+
+impl AddToolchainState {
+    fn select_scope(&mut self, scope: ToolchainScope, cx: &mut Context<Self>) {
+        if let AddState::Name { scope_picker, .. } = &mut self.state {
+            scope_picker.selected_scope = scope;
+            cx.notify();
+        }
+    }
+}
+
+impl Focusable for State {
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        match self {
+            State::Search(state) => state.picker.focus_handle(cx),
+            State::AddToolchain(state) => state.focus_handle(cx),
+        }
+    }
+}
+impl Render for AddToolchainState {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let theme = cx.theme().clone();
+        let weak = self.weak.upgrade();
+        let label = SharedString::new_static("Add");
+
+        v_flex()
+            .size_full()
+            // todo: These modal styles shouldn't be needed as the modal picker already has `elevation_3`
+            // They get duplicated in the middle state of adding a virtual env, but then are needed for this last state
+            .bg(cx.theme().colors().elevated_surface_background)
+            .border_1()
+            .border_color(cx.theme().colors().border_variant)
+            .rounded_lg()
+            .when_some(weak, |this, weak| {
+                this.on_action(window.listener_for(
+                    &weak,
+                    |this: &mut ToolchainSelector, _: &menu::Cancel, window, cx| {
+                        this.state = State::Search((this.create_search_state)(window, cx));
+                        this.state.focus_handle(cx).focus(window);
+                        cx.notify();
+                    },
+                ))
+            })
+            .on_action(cx.listener(Self::confirm_toolchain))
+            .map(|this| match &self.state {
+                AddState::Path { picker, .. } => this.child(picker.clone()),
+                AddState::Name {
+                    editor,
+                    scope_picker,
+                    ..
+                } => {
+                    let scope_options = [
+                        ToolchainScope::Global,
+                        ToolchainScope::Project,
+                        ToolchainScope::Subproject(
+                            self.root_path.worktree_id,
+                            self.root_path.path.clone(),
+                        ),
+                    ];
+
+                    let mut navigable_scope_picker = Navigable::new(
+                        v_flex()
+                            .child(
+                                h_flex()
+                                    .w_full()
+                                    .p_2()
+                                    .border_b_1()
+                                    .border_color(theme.colors().border)
+                                    .child(editor.clone()),
+                            )
+                            .child(
+                                v_flex()
+                                    .child(
+                                        Label::new("Scope")
+                                            .size(LabelSize::Small)
+                                            .color(Color::Muted)
+                                            .mt_1()
+                                            .ml_2(),
+                                    )
+                                    .child(List::new().children(
+                                        scope_options.iter().enumerate().map(|(i, scope)| {
+                                            let is_selected = *scope == scope_picker.selected_scope;
+                                            let label = scope.label();
+                                            let description = scope.description();
+                                            let scope_clone_for_action = scope.clone();
+                                            let scope_clone_for_click = scope.clone();
+
+                                            div()
+                                                .id(SharedString::from(format!("scope-option-{i}")))
+                                                .track_focus(&scope_picker.entries[i].focus_handle)
+                                                .on_action(cx.listener(
+                                                    move |this, _: &menu::Confirm, _, cx| {
+                                                        this.select_scope(
+                                                            scope_clone_for_action.clone(),
+                                                            cx,
+                                                        );
+                                                    },
+                                                ))
+                                                .child(
+                                                    ListItem::new(SharedString::from(format!(
+                                                        "scope-{i}"
+                                                    )))
+                                                    .toggle_state(
+                                                        is_selected
+                                                            || scope_picker.entries[i]
+                                                                .focus_handle
+                                                                .contains_focused(window, cx),
+                                                    )
+                                                    .inset(true)
+                                                    .spacing(ListItemSpacing::Sparse)
+                                                    .child(
+                                                        h_flex()
+                                                            .gap_2()
+                                                            .child(Label::new(label))
+                                                            .child(
+                                                                Label::new(description)
+                                                                    .size(LabelSize::Small)
+                                                                    .color(Color::Muted),
+                                                            ),
+                                                    )
+                                                    .on_click(cx.listener(move |this, _, _, cx| {
+                                                        this.select_scope(
+                                                            scope_clone_for_click.clone(),
+                                                            cx,
+                                                        );
+                                                    })),
+                                                )
+                                        }),
+                                    ))
+                                    .child(Divider::horizontal())
+                                    .child(h_flex().p_1p5().justify_end().map(|this| {
+                                        let is_disabled = editor.read(cx).is_empty(cx);
+                                        let handle = self.focus_handle(cx);
+                                        this.child(
+                                            Button::new("add-toolchain", label)
+                                                .disabled(is_disabled)
+                                                .key_binding(KeyBinding::for_action_in(
+                                                    &menu::Confirm,
+                                                    &handle,
+                                                    window,
+                                                    cx,
+                                                ))
+                                                .on_click(cx.listener(|this, _, window, cx| {
+                                                    this.confirm_toolchain(
+                                                        &menu::Confirm,
+                                                        window,
+                                                        cx,
+                                                    );
+                                                }))
+                                                .map(|this| {
+                                                    if false {
+                                                        this.with_animation(
+                                                            "inspecting-user-toolchain",
+                                                            Animation::new(Duration::from_millis(
+                                                                500,
+                                                            ))
+                                                            .repeat()
+                                                            .with_easing(pulsating_between(
+                                                                0.4, 0.8,
+                                                            )),
+                                                            |label, delta| label.alpha(delta),
+                                                        )
+                                                        .into_any()
+                                                    } else {
+                                                        this.into_any_element()
+                                                    }
+                                                }),
+                                        )
+                                    })),
+                            )
+                            .into_any_element(),
+                    );
+
+                    for entry in &scope_picker.entries {
+                        navigable_scope_picker = navigable_scope_picker.entry(entry.clone());
+                    }
+
+                    this.child(navigable_scope_picker.render(window, cx))
+                }
+            })
+    }
+}
+
+#[derive(Clone)]
+enum State {
+    Search(SearchState),
+    AddToolchain(Entity<AddToolchainState>),
+}
+
+impl RenderOnce for State {
+    fn render(self, _: &mut Window, _: &mut App) -> impl IntoElement {
+        match self {
+            State::Search(state) => state.picker.into_any_element(),
+            State::AddToolchain(state) => state.into_any_element(),
+        }
+    }
+}
 impl ToolchainSelector {
     fn register(
         workspace: &mut Workspace,
@@ -40,6 +558,16 @@ impl ToolchainSelector {
         workspace.register_action(move |workspace, _: &Select, window, cx| {
             Self::toggle(workspace, window, cx);
         });
+        workspace.register_action(move |workspace, _: &AddToolchain, window, cx| {
+            let Some(toolchain_selector) = workspace.active_modal::<Self>(cx) else {
+                Self::toggle(workspace, window, cx);
+                return;
+            };
+
+            toolchain_selector.update(cx, |toolchain_selector, cx| {
+                toolchain_selector.handle_add_toolchain(&AddToolchain, window, cx);
+            });
+        });
     }
 
     fn toggle(
@@ -105,35 +633,100 @@ impl ToolchainSelector {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
-        let toolchain_selector = cx.entity().downgrade();
-        let picker = cx.new(|cx| {
-            let delegate = ToolchainSelectorDelegate::new(
-                active_toolchain,
-                toolchain_selector,
-                workspace,
-                worktree_id,
-                worktree_root,
-                project,
-                relative_path,
-                language_name,
+        let language_registry = project.read(cx).languages().clone();
+        cx.spawn({
+            let language_name = language_name.clone();
+            async move |this, cx| {
+                let language = language_registry
+                    .language_for_name(&language_name.0)
+                    .await
+                    .ok();
+                this.update(cx, |this, cx| {
+                    this.language = language;
+                    cx.notify();
+                })
+                .ok();
+            }
+        })
+        .detach();
+        let project_clone = project.clone();
+        let language_name_clone = language_name.clone();
+        let relative_path_clone = relative_path.clone();
+
+        let create_search_state = Arc::new(move |window: &mut Window, cx: &mut Context<Self>| {
+            let toolchain_selector = cx.entity().downgrade();
+            let picker = cx.new(|cx| {
+                let delegate = ToolchainSelectorDelegate::new(
+                    active_toolchain.clone(),
+                    toolchain_selector,
+                    workspace.clone(),
+                    worktree_id,
+                    worktree_root.clone(),
+                    project_clone.clone(),
+                    relative_path_clone.clone(),
+                    language_name_clone.clone(),
+                    window,
+                    cx,
+                );
+                Picker::uniform_list(delegate, window, cx)
+            });
+            let picker_focus_handle = picker.focus_handle(cx);
+            picker.update(cx, |picker, _| {
+                picker.delegate.focus_handle = picker_focus_handle.clone();
+            });
+            SearchState { picker }
+        });
+
+        Self {
+            state: State::Search(create_search_state(window, cx)),
+            create_search_state,
+            language: None,
+            project,
+            language_name,
+            worktree_id,
+            relative_path,
+        }
+    }
+
+    fn handle_add_toolchain(
+        &mut self,
+        _: &AddToolchain,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if matches!(self.state, State::Search(_)) {
+            self.state = State::AddToolchain(AddToolchainState::new(
+                self.project.clone(),
+                self.language_name.clone(),
+                ProjectPath {
+                    worktree_id: self.worktree_id,
+                    path: self.relative_path.clone(),
+                },
                 window,
                 cx,
-            );
-            Picker::uniform_list(delegate, window, cx)
-        });
-        Self { picker }
+            ));
+            self.state.focus_handle(cx).focus(window);
+            cx.notify();
+        }
     }
 }
 
 impl Render for ToolchainSelector {
-    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
-        v_flex().w(rems(34.)).child(self.picker.clone())
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let mut key_context = KeyContext::new_with_defaults();
+        key_context.add("ToolchainSelector");
+
+        v_flex()
+            .key_context(key_context)
+            .w(rems(34.))
+            .on_action(cx.listener(Self::handle_add_toolchain))
+            .child(self.state.clone().render(window, cx))
     }
 }
 
 impl Focusable for ToolchainSelector {
     fn focus_handle(&self, cx: &App) -> FocusHandle {
-        self.picker.focus_handle(cx)
+        self.state.focus_handle(cx)
     }
 }
 
@@ -142,7 +735,7 @@ impl ModalView for ToolchainSelector {}
 
 pub struct ToolchainSelectorDelegate {
     toolchain_selector: WeakEntity<ToolchainSelector>,
-    candidates: ToolchainList,
+    candidates: Arc<[(Toolchain, Option<ToolchainScope>)]>,
     matches: Vec<StringMatch>,
     selected_index: usize,
     workspace: WeakEntity<Workspace>,
@@ -150,6 +743,9 @@ pub struct ToolchainSelectorDelegate {
     worktree_abs_path_root: Arc<Path>,
     relative_path: Arc<Path>,
     placeholder_text: Arc<str>,
+    add_toolchain_text: Arc<str>,
+    project: Entity<Project>,
+    focus_handle: FocusHandle,
     _fetch_candidates_task: Task<Option<()>>,
 }
 
@@ -166,19 +762,33 @@ impl ToolchainSelectorDelegate {
         window: &mut Window,
         cx: &mut Context<Picker<Self>>,
     ) -> Self {
+        let _project = project.clone();
+
         let _fetch_candidates_task = cx.spawn_in(window, {
             async move |this, cx| {
-                let term = project
+                let meta = _project
                     .read_with(cx, |this, _| {
-                        Project::toolchain_term(this.languages().clone(), language_name.clone())
+                        Project::toolchain_metadata(this.languages().clone(), language_name.clone())
                     })
                     .ok()?
                     .await?;
                 let relative_path = this
-                    .read_with(cx, |this, _| this.delegate.relative_path.clone())
+                    .update(cx, |this, cx| {
+                        this.delegate.add_toolchain_text = format!(
+                            "Add {}",
+                            meta.term.as_ref().to_case(convert_case::Case::Title)
+                        )
+                        .into();
+                        cx.notify();
+                        this.delegate.relative_path.clone()
+                    })
                     .ok()?;
 
-                let (available_toolchains, relative_path) = project
+                let Toolchains {
+                    toolchains: available_toolchains,
+                    root_path: relative_path,
+                    user_toolchains,
+                } = _project
                     .update(cx, |this, cx| {
                         this.available_toolchains(
                             ProjectPath {
@@ -200,7 +810,7 @@ impl ToolchainSelectorDelegate {
                     }
                 };
                 let placeholder_text =
-                    format!("Select a {} for {pretty_path}…", term.to_lowercase(),).into();
+                    format!("Select a {} for {pretty_path}…", meta.term.to_lowercase(),).into();
                 let _ = this.update_in(cx, move |this, window, cx| {
                     this.delegate.relative_path = relative_path;
                     this.delegate.placeholder_text = placeholder_text;
@@ -208,15 +818,27 @@ impl ToolchainSelectorDelegate {
                 });
 
                 let _ = this.update_in(cx, move |this, window, cx| {
-                    this.delegate.candidates = available_toolchains;
+                    this.delegate.candidates = user_toolchains
+                        .into_iter()
+                        .flat_map(|(scope, toolchains)| {
+                            toolchains
+                                .into_iter()
+                                .map(move |toolchain| (toolchain, Some(scope.clone())))
+                        })
+                        .chain(
+                            available_toolchains
+                                .toolchains
+                                .into_iter()
+                                .map(|toolchain| (toolchain, None)),
+                        )
+                        .collect();
 
                     if let Some(active_toolchain) = active_toolchain
                         && let Some(position) = this
                             .delegate
                             .candidates
-                            .toolchains
                             .iter()
-                            .position(|toolchain| *toolchain == active_toolchain)
+                            .position(|(toolchain, _)| *toolchain == active_toolchain)
                     {
                         this.delegate.set_selected_index(position, window, cx);
                     }
@@ -238,6 +860,9 @@ impl ToolchainSelectorDelegate {
             placeholder_text,
             relative_path,
             _fetch_candidates_task,
+            project,
+            focus_handle: cx.focus_handle(),
+            add_toolchain_text: Arc::from("Add Toolchain"),
         }
     }
     fn relativize_path(path: SharedString, worktree_root: &Path) -> SharedString {
@@ -263,7 +888,7 @@ impl PickerDelegate for ToolchainSelectorDelegate {
 
     fn confirm(&mut self, _: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
         if let Some(string_match) = self.matches.get(self.selected_index) {
-            let toolchain = self.candidates.toolchains[string_match.candidate_id].clone();
+            let (toolchain, _) = self.candidates[string_match.candidate_id].clone();
             if let Some(workspace_id) = self
                 .workspace
                 .read_with(cx, |this, _| this.database_id())
@@ -330,11 +955,11 @@ impl PickerDelegate for ToolchainSelectorDelegate {
         cx.spawn_in(window, async move |this, cx| {
             let matches = if query.is_empty() {
                 candidates
-                    .toolchains
                     .into_iter()
                     .enumerate()
-                    .map(|(index, candidate)| {
-                        let path = Self::relativize_path(candidate.path, &worktree_root_path);
+                    .map(|(index, (candidate, _))| {
+                        let path =
+                            Self::relativize_path(candidate.path.clone(), &worktree_root_path);
                         let string = format!("{}{}", candidate.name, path);
                         StringMatch {
                             candidate_id: index,
@@ -346,11 +971,11 @@ impl PickerDelegate for ToolchainSelectorDelegate {
                     .collect()
             } else {
                 let candidates = candidates
-                    .toolchains
                     .into_iter()
                     .enumerate()
-                    .map(|(candidate_id, toolchain)| {
-                        let path = Self::relativize_path(toolchain.path, &worktree_root_path);
+                    .map(|(candidate_id, (toolchain, _))| {
+                        let path =
+                            Self::relativize_path(toolchain.path.clone(), &worktree_root_path);
                         let string = format!("{}{}", toolchain.name, path);
                         StringMatchCandidate::new(candidate_id, &string)
                     })
@@ -383,11 +1008,11 @@ impl PickerDelegate for ToolchainSelectorDelegate {
         &self,
         ix: usize,
         selected: bool,
-        _window: &mut Window,
-        _: &mut Context<Picker<Self>>,
+        _: &mut Window,
+        cx: &mut Context<Picker<Self>>,
     ) -> Option<Self::ListItem> {
         let mat = &self.matches[ix];
-        let toolchain = &self.candidates.toolchains[mat.candidate_id];
+        let (toolchain, scope) = &self.candidates[mat.candidate_id];
 
         let label = toolchain.name.clone();
         let path = Self::relativize_path(toolchain.path.clone(), &self.worktree_abs_path_root);
@@ -399,8 +1024,9 @@ impl PickerDelegate for ToolchainSelectorDelegate {
         path_highlights.iter_mut().for_each(|index| {
             *index -= label.len();
         });
+        let id: SharedString = format!("toolchain-{ix}",).into();
         Some(
-            ListItem::new(ix)
+            ListItem::new(id)
                 .inset(true)
                 .spacing(ListItemSpacing::Sparse)
                 .toggle_state(selected)
@@ -409,7 +1035,89 @@ impl PickerDelegate for ToolchainSelectorDelegate {
                     HighlightedLabel::new(path, path_highlights)
                         .size(LabelSize::Small)
                         .color(Color::Muted),
-                ),
+                )
+                .when_some(scope.as_ref(), |this, scope| {
+                    let id: SharedString = format!(
+                        "delete-custom-toolchain-{}-{}",
+                        toolchain.name, toolchain.path
+                    )
+                    .into();
+                    let toolchain = toolchain.clone();
+                    let scope = scope.clone();
+
+                    this.end_slot(IconButton::new(id, IconName::Trash))
+                        .on_click(cx.listener(move |this, _, _, cx| {
+                            this.delegate.project.update(cx, |this, cx| {
+                                this.remove_toolchain(toolchain.clone(), scope.clone(), cx)
+                            });
+
+                            this.delegate.matches.retain_mut(|m| {
+                                if m.candidate_id == ix {
+                                    return false;
+                                } else if m.candidate_id > ix {
+                                    m.candidate_id -= 1;
+                                }
+                                true
+                            });
+
+                            this.delegate.candidates = this
+                                .delegate
+                                .candidates
+                                .iter()
+                                .enumerate()
+                                .filter_map(|(i, toolchain)| (ix != i).then_some(toolchain.clone()))
+                                .collect();
+
+                            if this.delegate.selected_index >= ix {
+                                this.delegate.selected_index =
+                                    this.delegate.selected_index.saturating_sub(1);
+                            }
+                            cx.stop_propagation();
+                            cx.notify();
+                        }))
+                }),
+        )
+    }
+    fn render_footer(
+        &self,
+        _window: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> Option<AnyElement> {
+        Some(
+            v_flex()
+                .rounded_b_md()
+                .child(Divider::horizontal())
+                .child(
+                    h_flex()
+                        .p_1p5()
+                        .gap_0p5()
+                        .justify_end()
+                        .child(
+                            Button::new("xd", self.add_toolchain_text.clone())
+                                .key_binding(KeyBinding::for_action_in(
+                                    &AddToolchain,
+                                    &self.focus_handle,
+                                    _window,
+                                    cx,
+                                ))
+                                .on_click(|_, window, cx| {
+                                    window.dispatch_action(Box::new(AddToolchain), cx)
+                                }),
+                        )
+                        .child(
+                            Button::new("select", "Select")
+                                .key_binding(KeyBinding::for_action_in(
+                                    &menu::Confirm,
+                                    &self.focus_handle,
+                                    _window,
+                                    cx,
+                                ))
+                                .on_click(|_, window, cx| {
+                                    window.dispatch_action(menu::Confirm.boxed_clone(), cx)
+                                }),
+                        ),
+                )
+                .into_any_element(),
         )
     }
 }
diff --git a/crates/ui/src/components/button/toggle_button.rs b/crates/ui/src/components/button/toggle_button.rs
index 2a862f4876a9bbd32d74de39066c82deeabce2ee..a50918b1094eaf75661c91d070d2d8cd8b364eb9 100644
--- a/crates/ui/src/components/button/toggle_button.rs
+++ b/crates/ui/src/components/button/toggle_button.rs
@@ -425,7 +425,7 @@ pub struct ToggleButtonGroup<T, const COLS: usize = 3, const ROWS: usize = 1>
 where
     T: ButtonBuilder,
 {
-    group_name: &'static str,
+    group_name: SharedString,
     rows: [[T; COLS]; ROWS],
     style: ToggleButtonGroupStyle,
     size: ToggleButtonGroupSize,
@@ -435,9 +435,9 @@ where
 }
 
 impl<T: ButtonBuilder, const COLS: usize> ToggleButtonGroup<T, COLS> {
-    pub fn single_row(group_name: &'static str, buttons: [T; COLS]) -> Self {
+    pub fn single_row(group_name: impl Into<SharedString>, buttons: [T; COLS]) -> Self {
         Self {
-            group_name,
+            group_name: group_name.into(),
             rows: [buttons],
             style: ToggleButtonGroupStyle::Transparent,
             size: ToggleButtonGroupSize::Default,
@@ -449,9 +449,13 @@ impl<T: ButtonBuilder, const COLS: usize> ToggleButtonGroup<T, COLS> {
 }
 
 impl<T: ButtonBuilder, const COLS: usize> ToggleButtonGroup<T, COLS, 2> {
-    pub fn two_rows(group_name: &'static str, first_row: [T; COLS], second_row: [T; COLS]) -> Self {
+    pub fn two_rows(
+        group_name: impl Into<SharedString>,
+        first_row: [T; COLS],
+        second_row: [T; COLS],
+    ) -> Self {
         Self {
-            group_name,
+            group_name: group_name.into(),
             rows: [first_row, second_row],
             style: ToggleButtonGroupStyle::Transparent,
             size: ToggleButtonGroupSize::Default,
@@ -512,6 +516,7 @@ impl<T: ButtonBuilder, const COLS: usize, const ROWS: usize> RenderOnce
     fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
         let entries =
             self.rows.into_iter().enumerate().map(|(row_index, row)| {
+                let group_name = self.group_name.clone();
                 row.into_iter().enumerate().map(move |(col_index, button)| {
                     let ButtonConfiguration {
                         label,
@@ -523,7 +528,7 @@ impl<T: ButtonBuilder, const COLS: usize, const ROWS: usize> RenderOnce
 
                     let entry_index = row_index * COLS + col_index;
 
-                    ButtonLike::new((self.group_name, entry_index))
+                    ButtonLike::new((group_name.clone(), entry_index))
                         .full_width()
                         .rounding(None)
                         .when_some(self.tab_index, |this, tab_index| {
diff --git a/crates/ui_input/src/ui_input.rs b/crates/ui_input/src/ui_input.rs
index 02f8ef89f3cb76d8ebb8f2468d9619c931ab9b9d..39a701c8e8d5c839204a9df6d33f307cc4214289 100644
--- a/crates/ui_input/src/ui_input.rs
+++ b/crates/ui_input/src/ui_input.rs
@@ -168,7 +168,7 @@ impl Render for SingleLineInput {
                     .py_1p5()
                     .flex_grow()
                     .text_color(style.text_color)
-                    .rounded_sm()
+                    .rounded_md()
                     .bg(style.background_color)
                     .border_1()
                     .border_color(style.border_color)
diff --git a/crates/util/src/util.rs b/crates/util/src/util.rs
index c66adb8b3a7ef93828e95683596f43b91f96f994..90f5be1c92875ac0b9b2d3e7352ae858371b3686 100644
--- a/crates/util/src/util.rs
+++ b/crates/util/src/util.rs
@@ -256,6 +256,9 @@ fn load_shell_from_passwd() -> Result<()> {
             &mut result,
         )
     };
+    anyhow::ensure!(!result.is_null(), "passwd entry for uid {} not found", uid);
+
+    // SAFETY: If `getpwuid_r` doesn't error, we have the entry here.
     let entry = unsafe { pwd.assume_init() };
 
     anyhow::ensure!(
@@ -264,7 +267,6 @@ fn load_shell_from_passwd() -> Result<()> {
         uid,
         status
     );
-    anyhow::ensure!(!result.is_null(), "passwd entry for uid {} not found", uid);
     anyhow::ensure!(
         entry.pw_uid == uid,
         "passwd entry has different uid ({}) than getuid ({}) returned",
@@ -815,7 +817,8 @@ pub fn defer<F: FnOnce()>(f: F) -> Deferred<F> {
 
 #[cfg(any(test, feature = "test-support"))]
 mod rng {
-    use rand::{Rng, seq::SliceRandom};
+    use rand::prelude::*;
+
     pub struct RandomCharIter<T: Rng> {
         rng: T,
         simple_text: bool,
@@ -840,18 +843,18 @@ mod rng {
 
         fn next(&mut self) -> Option<Self::Item> {
             if self.simple_text {
-                return if self.rng.gen_range(0..100) < 5 {
+                return if self.rng.random_range(0..100) < 5 {
                     Some('\n')
                 } else {
-                    Some(self.rng.gen_range(b'a'..b'z' + 1).into())
+                    Some(self.rng.random_range(b'a'..b'z' + 1).into())
                 };
             }
 
-            match self.rng.gen_range(0..100) {
+            match self.rng.random_range(0..100) {
                 // whitespace
                 0..=19 => [' ', '\n', '\r', '\t'].choose(&mut self.rng).copied(),
                 // two-byte greek letters
-                20..=32 => char::from_u32(self.rng.gen_range(('α' as u32)..('ω' as u32 + 1))),
+                20..=32 => char::from_u32(self.rng.random_range(('α' as u32)..('ω' as u32 + 1))),
                 // // three-byte characters
                 33..=45 => ['✋', '✅', '❌', '❎', '⭐']
                     .choose(&mut self.rng)
@@ -859,7 +862,7 @@ mod rng {
                 // // four-byte characters
                 46..=58 => ['🍐', '🏀', '🍗', '🎉'].choose(&mut self.rng).copied(),
                 // ascii letters
-                _ => Some(self.rng.gen_range(b'a'..b'z' + 1).into()),
+                _ => Some(self.rng.random_range(b'a'..b'z' + 1).into()),
             }
         }
     }
diff --git a/crates/vim/src/command.rs b/crates/vim/src/command.rs
index 29fe6aae0252bcc1ca5767f71b7c668ecae1b9a8..576fe5f634e04c8f4c5ac3dc9ce2ad206d169abb 100644
--- a/crates/vim/src/command.rs
+++ b/crates/vim/src/command.rs
@@ -1265,10 +1265,9 @@ fn generate_commands(_: &App) -> Vec<VimCommand> {
         VimCommand::str(("L", "explore"), "project_panel::ToggleFocus"),
         VimCommand::str(("S", "explore"), "project_panel::ToggleFocus"),
         VimCommand::str(("Ve", "xplore"), "project_panel::ToggleFocus"),
-        VimCommand::str(("te", "rm"), "terminal_panel::ToggleFocus"),
-        VimCommand::str(("T", "erm"), "terminal_panel::ToggleFocus"),
+        VimCommand::str(("te", "rm"), "terminal_panel::Toggle"),
+        VimCommand::str(("T", "erm"), "terminal_panel::Toggle"),
         VimCommand::str(("C", "ollab"), "collab_panel::ToggleFocus"),
-        VimCommand::str(("Ch", "at"), "chat_panel::ToggleFocus"),
         VimCommand::str(("No", "tifications"), "notification_panel::ToggleFocus"),
         VimCommand::str(("A", "I"), "agent::ToggleFocus"),
         VimCommand::str(("G", "it"), "git_panel::ToggleFocus"),
diff --git a/crates/vim/src/helix.rs b/crates/vim/src/helix.rs
index abde3a8ce6e8755bb49826fb408a6af36661f00c..34ef2b40ec1bad03957a22ef66c40f6f53697699 100644
--- a/crates/vim/src/helix.rs
+++ b/crates/vim/src/helix.rs
@@ -1,3 +1,7 @@
+mod boundary;
+mod object;
+mod select;
+
 use editor::display_map::DisplaySnapshot;
 use editor::{
     DisplayPoint, Editor, HideMouseCursorOrigin, SelectionEffects, ToOffset, ToPoint, movement,
diff --git a/crates/vim/src/helix/boundary.rs b/crates/vim/src/helix/boundary.rs
new file mode 100644
index 0000000000000000000000000000000000000000..77d31eea3327a853d21a68065e0adc6230ad2c5a
--- /dev/null
+++ b/crates/vim/src/helix/boundary.rs
@@ -0,0 +1,740 @@
+use std::{
+    cmp::Ordering,
+    ops::{Deref, DerefMut, Range},
+};
+
+use editor::{
+    DisplayPoint,
+    display_map::{DisplaySnapshot, ToDisplayPoint},
+    movement,
+};
+use language::{CharClassifier, CharKind};
+use text::Bias;
+
+use crate::helix::object::HelixTextObject;
+
+/// Text objects (after helix definition) that can easily be
+/// found by reading a buffer and comparing two neighboring chars
+/// until a start / end is found
+trait BoundedObject {
+    /// The next start since `from` (inclusive).
+    /// If outer is true it is the start of "a" object (m a) rather than "inner" object (m i).
+    fn next_start(&self, map: &DisplaySnapshot, from: Offset, outer: bool) -> Option<Offset>;
+    /// The next end since `from` (inclusive).
+    /// If outer is true it is the end of "a" object (m a) rather than "inner" object (m i).
+    fn next_end(&self, map: &DisplaySnapshot, from: Offset, outer: bool) -> Option<Offset>;
+    /// The previous start since `from` (inclusive).
+    /// If outer is true it is the start of "a" object (m a) rather than "inner" object (m i).
+    fn previous_start(&self, map: &DisplaySnapshot, from: Offset, outer: bool) -> Option<Offset>;
+    /// The previous end since `from` (inclusive).
+    /// If outer is true it is the end of "a" object (m a) rather than "inner" object (m i).
+    fn previous_end(&self, map: &DisplaySnapshot, from: Offset, outer: bool) -> Option<Offset>;
+
+    /// Whether the range inside the object can be zero characters wide.
+    /// If so, the trait assumes that these ranges can't be directly adjacent to each other.
+    fn inner_range_can_be_zero_width(&self) -> bool;
+    /// Whether the "ma" can exceed the "mi" range on both sides at the same time
+    fn surround_on_both_sides(&self) -> bool;
+    /// Whether the outer range of an object could overlap with the outer range of the neighboring
+    /// object. If so, they can't be nested.
+    fn ambiguous_outer(&self) -> bool;
+
+    fn can_be_zero_width(&self, around: bool) -> bool {
+        if around {
+            false
+        } else {
+            self.inner_range_can_be_zero_width()
+        }
+    }
+
+    /// Switches from an "mi" range to an "ma" one.
+    /// Assumes the inner range is valid.
+    fn around(&self, map: &DisplaySnapshot, inner_range: Range<Offset>) -> Range<Offset> {
+        if self.surround_on_both_sides() {
+            let start = self
+                .previous_start(map, inner_range.start, true)
+                .unwrap_or(inner_range.start);
+            let end = self
+                .next_end(map, inner_range.end, true)
+                .unwrap_or(inner_range.end);
+
+            return start..end;
+        }
+
+        let mut start = inner_range.start;
+        let end = self
+            .next_end(map, inner_range.end, true)
+            .unwrap_or(inner_range.end);
+        if end == inner_range.end {
+            start = self
+                .previous_start(map, inner_range.start, true)
+                .unwrap_or(inner_range.start)
+        }
+
+        start..end
+    }
+    /// Switches from an "ma" range to an "mi" one.
+    /// Assumes the inner range is valid.
+    fn inside(&self, map: &DisplaySnapshot, outer_range: Range<Offset>) -> Range<Offset> {
+        let inner_start = self
+            .next_start(map, outer_range.start, false)
+            .unwrap_or_else(|| {
+                log::warn!("The motion might not have found the text object correctly");
+                outer_range.start
+            });
+        let inner_end = self
+            .previous_end(map, outer_range.end, false)
+            .unwrap_or_else(|| {
+                log::warn!("The motion might not have found the text object correctly");
+                outer_range.end
+            });
+        inner_start..inner_end
+    }
+
+    /// The next end since `start` (inclusive) on the same nesting level.
+    fn close_at_end(&self, start: Offset, map: &DisplaySnapshot, outer: bool) -> Option<Offset> {
+        let mut end_search_start = if self.can_be_zero_width(outer) {
+            start
+        } else {
+            start.next(map)?
+        };
+        let mut start_search_start = start.next(map)?;
+
+        loop {
+            let next_end = self.next_end(map, end_search_start, outer)?;
+            let maybe_next_start = self.next_start(map, start_search_start, outer);
+            if let Some(next_start) = maybe_next_start
+                && (*next_start < *next_end
+                    || *next_start == *next_end && self.can_be_zero_width(outer))
+                && !self.ambiguous_outer()
+            {
+                let closing = self.close_at_end(next_start, map, outer)?;
+                end_search_start = closing.next(map)?;
+                start_search_start = if self.can_be_zero_width(outer) {
+                    closing.next(map)?
+                } else {
+                    closing
+                };
+            } else {
+                return Some(next_end);
+            }
+        }
+    }
+    /// The previous start since `end` (inclusive) on the same nesting level.
+    fn close_at_start(&self, end: Offset, map: &DisplaySnapshot, outer: bool) -> Option<Offset> {
+        let mut start_search_end = if self.can_be_zero_width(outer) {
+            end
+        } else {
+            end.previous(map)?
+        };
+        let mut end_search_end = end.previous(map)?;
+
+        loop {
+            let previous_start = self.previous_start(map, start_search_end, outer)?;
+            let maybe_previous_end = self.previous_end(map, end_search_end, outer);
+            if let Some(previous_end) = maybe_previous_end
+                && (*previous_end > *previous_start
+                    || *previous_end == *previous_start && self.can_be_zero_width(outer))
+                && !self.ambiguous_outer()
+            {
+                let closing = self.close_at_start(previous_end, map, outer)?;
+                start_search_end = closing.previous(map)?;
+                end_search_end = if self.can_be_zero_width(outer) {
+                    closing.previous(map)?
+                } else {
+                    closing
+                };
+            } else {
+                return Some(previous_start);
+            }
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Debug)]
+struct Offset(usize);
+impl Deref for Offset {
+    type Target = usize;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl DerefMut for Offset {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl Offset {
+    fn next(self, map: &DisplaySnapshot) -> Option<Self> {
+        let next = Self(map.buffer_snapshot.clip_offset(*self + 1, Bias::Right));
+        (*next > *self).then(|| next)
+    }
+    fn previous(self, map: &DisplaySnapshot) -> Option<Self> {
+        if *self == 0 {
+            return None;
+        }
+        Some(Self(map.buffer_snapshot.clip_offset(*self - 1, Bias::Left)))
+    }
+    fn range(
+        start: (DisplayPoint, Bias),
+        end: (DisplayPoint, Bias),
+        map: &DisplaySnapshot,
+    ) -> Range<Self> {
+        Self(start.0.to_offset(map, start.1))..Self(end.0.to_offset(map, end.1))
+    }
+}
+
+impl<B: BoundedObject> HelixTextObject for B {
+    fn range(
+        &self,
+        map: &DisplaySnapshot,
+        relative_to: Range<DisplayPoint>,
+        around: bool,
+    ) -> Option<Range<DisplayPoint>> {
+        let relative_to = Offset::range(
+            (relative_to.start, Bias::Left),
+            (relative_to.end, Bias::Left),
+            map,
+        );
+
+        relative_range(self, around, map, |find_outer| {
+            let search_start = if self.can_be_zero_width(find_outer) {
+                relative_to.end
+            } else {
+                // If the objects can be directly next to each other an object end the
+                // cursor (relative_to) end would not count for close_at_end, so the search
+                // needs to start one character to the left.
+                relative_to.end.previous(map)?
+            };
+            let max_end = self.close_at_end(search_start, map, find_outer)?;
+            let min_start = self.close_at_start(max_end, map, find_outer)?;
+
+            (*min_start <= *relative_to.start).then(|| min_start..max_end)
+        })
+    }
+
+    fn next_range(
+        &self,
+        map: &DisplaySnapshot,
+        relative_to: Range<DisplayPoint>,
+        around: bool,
+    ) -> Option<Range<DisplayPoint>> {
+        let relative_to = Offset::range(
+            (relative_to.start, Bias::Left),
+            (relative_to.end, Bias::Left),
+            map,
+        );
+
+        relative_range(self, around, map, |find_outer| {
+            let min_start = self.next_start(map, relative_to.end, find_outer)?;
+            let max_end = self.close_at_end(min_start, map, find_outer)?;
+
+            Some(min_start..max_end)
+        })
+    }
+
+    fn previous_range(
+        &self,
+        map: &DisplaySnapshot,
+        relative_to: Range<DisplayPoint>,
+        around: bool,
+    ) -> Option<Range<DisplayPoint>> {
+        let relative_to = Offset::range(
+            (relative_to.start, Bias::Left),
+            (relative_to.end, Bias::Left),
+            map,
+        );
+
+        relative_range(self, around, map, |find_outer| {
+            let max_end = self.previous_end(map, relative_to.start, find_outer)?;
+            let min_start = self.close_at_start(max_end, map, find_outer)?;
+
+            Some(min_start..max_end)
+        })
+    }
+}
+
+fn relative_range<B: BoundedObject>(
+    object: &B,
+    outer: bool,
+    map: &DisplaySnapshot,
+    find_range: impl Fn(bool) -> Option<Range<Offset>>,
+) -> Option<Range<DisplayPoint>> {
+    // The cursor could be inside the outer range, but not the inner range.
+    // Whether that should count as found.
+    let find_outer = object.surround_on_both_sides() && !object.ambiguous_outer();
+    let range = find_range(find_outer)?;
+    let min_start = range.start;
+    let max_end = range.end;
+
+    let wanted_range = if outer && !find_outer {
+        // max_end is not yet the outer end
+        object.around(map, min_start..max_end)
+    } else if !outer && find_outer {
+        // max_end is the outer end, but the final result should have the inner end
+        object.inside(map, min_start..max_end)
+    } else {
+        min_start..max_end
+    };
+
+    let start = wanted_range.start.clone().to_display_point(map);
+    let end = wanted_range.end.clone().to_display_point(map);
+
+    Some(start..end)
+}
+
+/// A textobject whose boundaries can easily be found between two chars
+pub enum ImmediateBoundary {
+    Word { ignore_punctuation: bool },
+    Subword { ignore_punctuation: bool },
+    AngleBrackets,
+    BackQuotes,
+    CurlyBrackets,
+    DoubleQuotes,
+    Parentheses,
+    SingleQuotes,
+    SquareBrackets,
+    VerticalBars,
+}
+
+/// A textobject whose start and end can be found from an easy-to-find
+/// boundary between two chars by following a simple path from there
+pub enum FuzzyBoundary {
+    Sentence,
+    Paragraph,
+}
+
+impl ImmediateBoundary {
+    fn is_inner_start(&self, left: char, right: char, classifier: CharClassifier) -> bool {
+        match self {
+            Self::Word { ignore_punctuation } => {
+                let classifier = classifier.ignore_punctuation(*ignore_punctuation);
+                is_word_start(left, right, &classifier)
+                    || (is_buffer_start(left) && classifier.kind(right) != CharKind::Whitespace)
+            }
+            Self::Subword { ignore_punctuation } => {
+                let classifier = classifier.ignore_punctuation(*ignore_punctuation);
+                movement::is_subword_start(left, right, &classifier)
+                    || (is_buffer_start(left) && classifier.kind(right) != CharKind::Whitespace)
+            }
+            Self::AngleBrackets => left == '<',
+            Self::BackQuotes => left == '`',
+            Self::CurlyBrackets => left == '{',
+            Self::DoubleQuotes => left == '"',
+            Self::Parentheses => left == '(',
+            Self::SingleQuotes => left == '\'',
+            Self::SquareBrackets => left == '[',
+            Self::VerticalBars => left == '|',
+        }
+    }
+    fn is_inner_end(&self, left: char, right: char, classifier: CharClassifier) -> bool {
+        match self {
+            Self::Word { ignore_punctuation } => {
+                let classifier = classifier.ignore_punctuation(*ignore_punctuation);
+                is_word_end(left, right, &classifier)
+                    || (is_buffer_end(right) && classifier.kind(left) != CharKind::Whitespace)
+            }
+            Self::Subword { ignore_punctuation } => {
+                let classifier = classifier.ignore_punctuation(*ignore_punctuation);
+                movement::is_subword_start(left, right, &classifier)
+                    || (is_buffer_end(right) && classifier.kind(left) != CharKind::Whitespace)
+            }
+            Self::AngleBrackets => right == '>',
+            Self::BackQuotes => right == '`',
+            Self::CurlyBrackets => right == '}',
+            Self::DoubleQuotes => right == '"',
+            Self::Parentheses => right == ')',
+            Self::SingleQuotes => right == '\'',
+            Self::SquareBrackets => right == ']',
+            Self::VerticalBars => right == '|',
+        }
+    }
+    fn is_outer_start(&self, left: char, right: char, classifier: CharClassifier) -> bool {
+        match self {
+            word @ Self::Word { .. } => word.is_inner_end(left, right, classifier) || left == '\n',
+            subword @ Self::Subword { .. } => {
+                subword.is_inner_end(left, right, classifier) || left == '\n'
+            }
+            Self::AngleBrackets => right == '<',
+            Self::BackQuotes => right == '`',
+            Self::CurlyBrackets => right == '{',
+            Self::DoubleQuotes => right == '"',
+            Self::Parentheses => right == '(',
+            Self::SingleQuotes => right == '\'',
+            Self::SquareBrackets => right == '[',
+            Self::VerticalBars => right == '|',
+        }
+    }
+    fn is_outer_end(&self, left: char, right: char, classifier: CharClassifier) -> bool {
+        match self {
+            word @ Self::Word { .. } => {
+                word.is_inner_start(left, right, classifier) || right == '\n'
+            }
+            subword @ Self::Subword { .. } => {
+                subword.is_inner_start(left, right, classifier) || right == '\n'
+            }
+            Self::AngleBrackets => left == '>',
+            Self::BackQuotes => left == '`',
+            Self::CurlyBrackets => left == '}',
+            Self::DoubleQuotes => left == '"',
+            Self::Parentheses => left == ')',
+            Self::SingleQuotes => left == '\'',
+            Self::SquareBrackets => left == ']',
+            Self::VerticalBars => left == '|',
+        }
+    }
+}
+
+impl BoundedObject for ImmediateBoundary {
+    fn next_start(&self, map: &DisplaySnapshot, from: Offset, outer: bool) -> Option<Offset> {
+        try_find_boundary(map, from, |left, right| {
+            let classifier = map.buffer_snapshot.char_classifier_at(*from);
+            if outer {
+                self.is_outer_start(left, right, classifier)
+            } else {
+                self.is_inner_start(left, right, classifier)
+            }
+        })
+    }
+    fn next_end(&self, map: &DisplaySnapshot, from: Offset, outer: bool) -> Option<Offset> {
+        try_find_boundary(map, from, |left, right| {
+            let classifier = map.buffer_snapshot.char_classifier_at(*from);
+            if outer {
+                self.is_outer_end(left, right, classifier)
+            } else {
+                self.is_inner_end(left, right, classifier)
+            }
+        })
+    }
+    fn previous_start(&self, map: &DisplaySnapshot, from: Offset, outer: bool) -> Option<Offset> {
+        try_find_preceding_boundary(map, from, |left, right| {
+            let classifier = map.buffer_snapshot.char_classifier_at(*from);
+            if outer {
+                self.is_outer_start(left, right, classifier)
+            } else {
+                self.is_inner_start(left, right, classifier)
+            }
+        })
+    }
+    fn previous_end(&self, map: &DisplaySnapshot, from: Offset, outer: bool) -> Option<Offset> {
+        try_find_preceding_boundary(map, from, |left, right| {
+            let classifier = map.buffer_snapshot.char_classifier_at(*from);
+            if outer {
+                self.is_outer_end(left, right, classifier)
+            } else {
+                self.is_inner_end(left, right, classifier)
+            }
+        })
+    }
+    fn inner_range_can_be_zero_width(&self) -> bool {
+        match self {
+            Self::Subword { .. } | Self::Word { .. } => false,
+            _ => true,
+        }
+    }
+    fn surround_on_both_sides(&self) -> bool {
+        match self {
+            Self::Subword { .. } | Self::Word { .. } => false,
+            _ => true,
+        }
+    }
+    fn ambiguous_outer(&self) -> bool {
+        match self {
+            Self::BackQuotes
+            | Self::DoubleQuotes
+            | Self::SingleQuotes
+            | Self::VerticalBars
+            | Self::Subword { .. }
+            | Self::Word { .. } => true,
+            _ => false,
+        }
+    }
+}
+
+impl FuzzyBoundary {
+    /// When between two chars that form an easy-to-find identifier boundary,
+    /// what's the way to get to the actual start of the object, if any
+    fn is_near_potential_inner_start<'a>(
+        &self,
+        left: char,
+        right: char,
+        classifier: &CharClassifier,
+    ) -> Option<Box<dyn Fn(Offset, &'a DisplaySnapshot) -> Option<Offset>>> {
+        if is_buffer_start(left) {
+            return Some(Box::new(|identifier, _| Some(identifier)));
+        }
+        match self {
+            Self::Paragraph => {
+                if left != '\n' || right != '\n' {
+                    return None;
+                }
+                Some(Box::new(|identifier, map| {
+                    try_find_boundary(map, identifier, |left, right| left == '\n' && right != '\n')
+                }))
+            }
+            Self::Sentence => {
+                if let Some(find_paragraph_start) =
+                    Self::Paragraph.is_near_potential_inner_start(left, right, classifier)
+                {
+                    return Some(find_paragraph_start);
+                } else if !is_sentence_end(left, right, classifier) {
+                    return None;
+                }
+                Some(Box::new(|identifier, map| {
+                    let word = ImmediateBoundary::Word {
+                        ignore_punctuation: false,
+                    };
+                    word.next_start(map, identifier, false)
+                }))
+            }
+        }
+    }
+    /// When between two chars that form an easy-to-find identifier boundary,
+    /// what's the way to get to the actual end of the object, if any
+    fn is_near_potential_inner_end<'a>(
+        &self,
+        left: char,
+        right: char,
+        classifier: &CharClassifier,
+    ) -> Option<Box<dyn Fn(Offset, &'a DisplaySnapshot) -> Option<Offset>>> {
+        if is_buffer_end(right) {
+            return Some(Box::new(|identifier, _| Some(identifier)));
+        }
+        match self {
+            Self::Paragraph => {
+                if left != '\n' || right != '\n' {
+                    return None;
+                }
+                Some(Box::new(|identifier, map| {
+                    try_find_preceding_boundary(map, identifier, |left, right| {
+                        left != '\n' && right == '\n'
+                    })
+                }))
+            }
+            Self::Sentence => {
+                if let Some(find_paragraph_end) =
+                    Self::Paragraph.is_near_potential_inner_end(left, right, classifier)
+                {
+                    return Some(find_paragraph_end);
+                } else if !is_sentence_end(left, right, classifier) {
+                    return None;
+                }
+                Some(Box::new(|identifier, _| Some(identifier)))
+            }
+        }
+    }
+    /// When between two chars that form an easy-to-find identifier boundary,
+    /// what's the way to get to the actual end of the object, if any
+    fn is_near_potential_outer_start<'a>(
+        &self,
+        left: char,
+        right: char,
+        classifier: &CharClassifier,
+    ) -> Option<Box<dyn Fn(Offset, &'a DisplaySnapshot) -> Option<Offset>>> {
+        match self {
+            paragraph @ Self::Paragraph => {
+                paragraph.is_near_potential_inner_end(left, right, classifier)
+            }
+            sentence @ Self::Sentence => {
+                sentence.is_near_potential_inner_end(left, right, classifier)
+            }
+        }
+    }
+    /// When between two chars that form an easy-to-find identifier boundary,
+    /// what's the way to get to the actual end of the object, if any
+    fn is_near_potential_outer_end<'a>(
+        &self,
+        left: char,
+        right: char,
+        classifier: &CharClassifier,
+    ) -> Option<Box<dyn Fn(Offset, &'a DisplaySnapshot) -> Option<Offset>>> {
+        match self {
+            paragraph @ Self::Paragraph => {
+                paragraph.is_near_potential_inner_start(left, right, classifier)
+            }
+            sentence @ Self::Sentence => {
+                sentence.is_near_potential_inner_start(left, right, classifier)
+            }
+        }
+    }
+
+    // The boundary can be on the other side of `from` than the identifier, so the search needs to go both ways.
+    // Also, the distance (and direction) between identifier and boundary could vary, so a few ones need to be
+    // compared, even if one boundary was already found on the right side of `from`.
+    fn to_boundary(
+        &self,
+        map: &DisplaySnapshot,
+        from: Offset,
+        outer: bool,
+        backward: bool,
+        boundary_kind: Boundary,
+    ) -> Option<Offset> {
+        let generate_boundary_data = |left, right, point: Offset| {
+            let classifier = map.buffer_snapshot.char_classifier_at(*from);
+            let reach_boundary = if outer && boundary_kind == Boundary::Start {
+                self.is_near_potential_outer_start(left, right, &classifier)
+            } else if !outer && boundary_kind == Boundary::Start {
+                self.is_near_potential_inner_start(left, right, &classifier)
+            } else if outer && boundary_kind == Boundary::End {
+                self.is_near_potential_outer_end(left, right, &classifier)
+            } else {
+                self.is_near_potential_inner_end(left, right, &classifier)
+            };
+
+            reach_boundary.map(|reach_start| (point, reach_start))
+        };
+
+        let forwards = try_find_boundary_data(map, from, generate_boundary_data);
+        let backwards = try_find_preceding_boundary_data(map, from, generate_boundary_data);
+        let boundaries = [forwards, backwards]
+            .into_iter()
+            .flatten()
+            .filter_map(|(identifier, reach_boundary)| reach_boundary(identifier, map))
+            .filter(|boundary| match boundary.cmp(&from) {
+                Ordering::Equal => true,
+                Ordering::Less => backward,
+                Ordering::Greater => !backward,
+            });
+        if backward {
+            boundaries.max_by_key(|boundary| **boundary)
+        } else {
+            boundaries.min_by_key(|boundary| **boundary)
+        }
+    }
+}
+
+#[derive(PartialEq)]
+enum Boundary {
+    Start,
+    End,
+}
+
+impl BoundedObject for FuzzyBoundary {
+    fn next_start(&self, map: &DisplaySnapshot, from: Offset, outer: bool) -> Option<Offset> {
+        self.to_boundary(map, from, outer, false, Boundary::Start)
+    }
+    fn next_end(&self, map: &DisplaySnapshot, from: Offset, outer: bool) -> Option<Offset> {
+        self.to_boundary(map, from, outer, false, Boundary::End)
+    }
+    fn previous_start(&self, map: &DisplaySnapshot, from: Offset, outer: bool) -> Option<Offset> {
+        self.to_boundary(map, from, outer, true, Boundary::Start)
+    }
+    fn previous_end(&self, map: &DisplaySnapshot, from: Offset, outer: bool) -> Option<Offset> {
+        self.to_boundary(map, from, outer, true, Boundary::End)
+    }
+    fn inner_range_can_be_zero_width(&self) -> bool {
+        false
+    }
+    fn surround_on_both_sides(&self) -> bool {
+        false
+    }
+    fn ambiguous_outer(&self) -> bool {
+        false
+    }
+}
+
+/// Returns the first boundary after or at `from` in text direction.
+/// The start and end of the file are the chars `'\0'`.
+fn try_find_boundary(
+    map: &DisplaySnapshot,
+    from: Offset,
+    is_boundary: impl Fn(char, char) -> bool,
+) -> Option<Offset> {
+    let boundary = try_find_boundary_data(map, from, |left, right, point| {
+        if is_boundary(left, right) {
+            Some(point)
+        } else {
+            None
+        }
+    })?;
+    Some(boundary)
+}
+
+/// Returns some information about it (of type `T`) as soon as
+/// there is a boundary after or at `from` in text direction
+/// The start and end of the file are the chars `'\0'`.
+fn try_find_boundary_data<T>(
+    map: &DisplaySnapshot,
+    mut from: Offset,
+    boundary_information: impl Fn(char, char, Offset) -> Option<T>,
+) -> Option<T> {
+    let mut prev_ch = map
+        .buffer_snapshot
+        .reversed_chars_at(*from)
+        .next()
+        .unwrap_or('\0');
+
+    for ch in map.buffer_snapshot.chars_at(*from).chain(['\0']) {
+        if let Some(boundary_information) = boundary_information(prev_ch, ch, from) {
+            return Some(boundary_information);
+        }
+        *from += ch.len_utf8();
+        prev_ch = ch;
+    }
+
+    None
+}
+
+/// Returns the first boundary after or at `from` in text direction.
+/// The start and end of the file are the chars `'\0'`.
+fn try_find_preceding_boundary(
+    map: &DisplaySnapshot,
+    from: Offset,
+    is_boundary: impl Fn(char, char) -> bool,
+) -> Option<Offset> {
+    let boundary = try_find_preceding_boundary_data(map, from, |left, right, point| {
+        if is_boundary(left, right) {
+            Some(point)
+        } else {
+            None
+        }
+    })?;
+    Some(boundary)
+}
+
+/// Returns some information about it (of type `T`) as soon as
+/// there is a boundary before or at `from` in opposite text direction
+/// The start and end of the file are the chars `'\0'`.
+fn try_find_preceding_boundary_data<T>(
+    map: &DisplaySnapshot,
+    mut from: Offset,
+    is_boundary: impl Fn(char, char, Offset) -> Option<T>,
+) -> Option<T> {
+    let mut prev_ch = map.buffer_snapshot.chars_at(*from).next().unwrap_or('\0');
+
+    for ch in map.buffer_snapshot.reversed_chars_at(*from).chain(['\0']) {
+        if let Some(boundary_information) = is_boundary(ch, prev_ch, from) {
+            return Some(boundary_information);
+        }
+        from.0 = from.0.saturating_sub(ch.len_utf8());
+        prev_ch = ch;
+    }
+
+    None
+}
+
+fn is_buffer_start(left: char) -> bool {
+    left == '\0'
+}
+
+fn is_buffer_end(right: char) -> bool {
+    right == '\0'
+}
+
+fn is_word_start(left: char, right: char, classifier: &CharClassifier) -> bool {
+    classifier.kind(left) != classifier.kind(right)
+        && classifier.kind(right) != CharKind::Whitespace
+}
+
+fn is_word_end(left: char, right: char, classifier: &CharClassifier) -> bool {
+    classifier.kind(left) != classifier.kind(right) && classifier.kind(left) != CharKind::Whitespace
+}
+
+fn is_sentence_end(left: char, right: char, classifier: &CharClassifier) -> bool {
+    const ENDS: [char; 1] = ['.'];
+
+    if classifier.kind(right) != CharKind::Whitespace {
+        return false;
+    }
+    ENDS.into_iter().any(|end| left == end)
+}
diff --git a/crates/vim/src/helix/object.rs b/crates/vim/src/helix/object.rs
new file mode 100644
index 0000000000000000000000000000000000000000..798cd7162eb58a56c7362aa5fdcb37a33d48daa8
--- /dev/null
+++ b/crates/vim/src/helix/object.rs
@@ -0,0 +1,182 @@
+use std::{
+    error::Error,
+    fmt::{self, Display},
+    ops::Range,
+};
+
+use editor::{DisplayPoint, display_map::DisplaySnapshot, movement};
+use text::Selection;
+
+use crate::{
+    helix::boundary::{FuzzyBoundary, ImmediateBoundary},
+    object::Object as VimObject,
+};
+
+/// A text object from helix or an extra one
+pub trait HelixTextObject {
+    fn range(
+        &self,
+        map: &DisplaySnapshot,
+        relative_to: Range<DisplayPoint>,
+        around: bool,
+    ) -> Option<Range<DisplayPoint>>;
+
+    fn next_range(
+        &self,
+        map: &DisplaySnapshot,
+        relative_to: Range<DisplayPoint>,
+        around: bool,
+    ) -> Option<Range<DisplayPoint>>;
+
+    fn previous_range(
+        &self,
+        map: &DisplaySnapshot,
+        relative_to: Range<DisplayPoint>,
+        around: bool,
+    ) -> Option<Range<DisplayPoint>>;
+}
+
+impl VimObject {
+    /// Returns the range of the object the cursor is over.
+    /// Follows helix convention.
+    pub fn helix_range(
+        self,
+        map: &DisplaySnapshot,
+        selection: Selection<DisplayPoint>,
+        around: bool,
+    ) -> Result<Option<Range<DisplayPoint>>, VimToHelixError> {
+        let cursor = cursor_range(&selection, map);
+        if let Some(helix_object) = self.to_helix_object() {
+            Ok(helix_object.range(map, cursor, around))
+        } else {
+            Err(VimToHelixError)
+        }
+    }
+    /// Returns the range of the next object the cursor is not over.
+    /// Follows helix convention.
+    pub fn helix_next_range(
+        self,
+        map: &DisplaySnapshot,
+        selection: Selection<DisplayPoint>,
+        around: bool,
+    ) -> Result<Option<Range<DisplayPoint>>, VimToHelixError> {
+        let cursor = cursor_range(&selection, map);
+        if let Some(helix_object) = self.to_helix_object() {
+            Ok(helix_object.next_range(map, cursor, around))
+        } else {
+            Err(VimToHelixError)
+        }
+    }
+    /// Returns the range of the previous object the cursor is not over.
+    /// Follows helix convention.
+    pub fn helix_previous_range(
+        self,
+        map: &DisplaySnapshot,
+        selection: Selection<DisplayPoint>,
+        around: bool,
+    ) -> Result<Option<Range<DisplayPoint>>, VimToHelixError> {
+        let cursor = cursor_range(&selection, map);
+        if let Some(helix_object) = self.to_helix_object() {
+            Ok(helix_object.previous_range(map, cursor, around))
+        } else {
+            Err(VimToHelixError)
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct VimToHelixError;
+impl Display for VimToHelixError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "Not all vim text objects have an implemented helix equivalent"
+        )
+    }
+}
+impl Error for VimToHelixError {}
+
+impl VimObject {
+    fn to_helix_object(self) -> Option<Box<dyn HelixTextObject>> {
+        Some(match self {
+            Self::AngleBrackets => Box::new(ImmediateBoundary::AngleBrackets),
+            Self::BackQuotes => Box::new(ImmediateBoundary::BackQuotes),
+            Self::CurlyBrackets => Box::new(ImmediateBoundary::CurlyBrackets),
+            Self::DoubleQuotes => Box::new(ImmediateBoundary::DoubleQuotes),
+            Self::Paragraph => Box::new(FuzzyBoundary::Paragraph),
+            Self::Parentheses => Box::new(ImmediateBoundary::Parentheses),
+            Self::Quotes => Box::new(ImmediateBoundary::SingleQuotes),
+            Self::Sentence => Box::new(FuzzyBoundary::Sentence),
+            Self::SquareBrackets => Box::new(ImmediateBoundary::SquareBrackets),
+            Self::Subword { ignore_punctuation } => {
+                Box::new(ImmediateBoundary::Subword { ignore_punctuation })
+            }
+            Self::VerticalBars => Box::new(ImmediateBoundary::VerticalBars),
+            Self::Word { ignore_punctuation } => {
+                Box::new(ImmediateBoundary::Word { ignore_punctuation })
+            }
+            _ => return None,
+        })
+    }
+}
+
+/// Returns the start of the cursor of a selection, whether that is collapsed or not.
+pub(crate) fn cursor_range(
+    selection: &Selection<DisplayPoint>,
+    map: &DisplaySnapshot,
+) -> Range<DisplayPoint> {
+    if selection.is_empty() | selection.reversed {
+        selection.head()..movement::right(map, selection.head())
+    } else {
+        movement::left(map, selection.head())..selection.head()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use db::indoc;
+
+    use crate::{state::Mode, test::VimTestContext};
+
+    #[gpui::test]
+    async fn test_select_word_object(cx: &mut gpui::TestAppContext) {
+        let mut cx = VimTestContext::new(cx, true).await;
+        let start = indoc! {"
+                The quick brˇowˇnˇ
+                fox «ˇjumps» ov«er
+                the laˇ»zy dogˇ
+
+                "
+        };
+
+        cx.set_state(start, Mode::HelixNormal);
+
+        cx.simulate_keystrokes("m i w");
+
+        cx.assert_state(
+            indoc! {"
+            The quick «brownˇ»
+            fox «jumpsˇ» over
+            the «lazyˇ» dogˇ
+
+            "
+            },
+            Mode::HelixNormal,
+        );
+
+        cx.set_state(start, Mode::HelixNormal);
+
+        cx.simulate_keystrokes("m a w");
+
+        cx.assert_state(
+            indoc! {"
+            The quick« brownˇ»
+            fox «jumps ˇ»over
+            the «lazy ˇ»dogˇ
+
+            "
+            },
+            Mode::HelixNormal,
+        );
+    }
+}
diff --git a/crates/vim/src/helix/select.rs b/crates/vim/src/helix/select.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d782e8b4505691060b0a0898f9a71047ed7956cf
--- /dev/null
+++ b/crates/vim/src/helix/select.rs
@@ -0,0 +1,84 @@
+use text::SelectionGoal;
+use ui::{Context, Window};
+
+use crate::{Vim, helix::object::cursor_range, object::Object};
+
+impl Vim {
+    /// Selects the object each cursor is over.
+    /// Follows helix convention.
+    pub fn select_current_object(
+        &mut self,
+        object: Object,
+        around: bool,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.stop_recording(cx);
+        self.update_editor(cx, |_, editor, cx| {
+            editor.change_selections(Default::default(), window, cx, |s| {
+                s.move_with(|map, selection| {
+                    let Some(range) = object
+                        .helix_range(map, selection.clone(), around)
+                        .unwrap_or({
+                            let vim_range = object.range(map, selection.clone(), around, None);
+                            vim_range.filter(|r| r.start <= cursor_range(selection, map).start)
+                        })
+                    else {
+                        return;
+                    };
+
+                    selection.set_head_tail(range.end, range.start, SelectionGoal::None);
+                });
+            });
+        });
+    }
+
+    /// Selects the next object from each cursor which the cursor is not over.
+    /// Follows helix convention.
+    pub fn select_next_object(
+        &mut self,
+        object: Object,
+        around: bool,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.stop_recording(cx);
+        self.update_editor(cx, |_, editor, cx| {
+            editor.change_selections(Default::default(), window, cx, |s| {
+                s.move_with(|map, selection| {
+                    let Ok(Some(range)) = object.helix_next_range(map, selection.clone(), around)
+                    else {
+                        return;
+                    };
+
+                    selection.set_head_tail(range.end, range.start, SelectionGoal::None);
+                });
+            });
+        });
+    }
+
+    /// Selects the previous object from each cursor which the cursor is not over.
+    /// Follows helix convention.
+    pub fn select_previous_object(
+        &mut self,
+        object: Object,
+        around: bool,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.stop_recording(cx);
+        self.update_editor(cx, |_, editor, cx| {
+            editor.change_selections(Default::default(), window, cx, |s| {
+                s.move_with(|map, selection| {
+                    let Ok(Some(range)) =
+                        object.helix_previous_range(map, selection.clone(), around)
+                    else {
+                        return;
+                    };
+
+                    selection.set_head_tail(range.start, range.end, SelectionGoal::None);
+                });
+            });
+        });
+    }
+}
diff --git a/crates/vim/src/normal.rs b/crates/vim/src/normal.rs
index 0c7b6e55a10f60f673cc44dddd0710f03a7d0435..b8d1325a8b19aaa2dcbc2611b2ff66df721c17f3 100644
--- a/crates/vim/src/normal.rs
+++ b/crates/vim/src/normal.rs
@@ -495,10 +495,19 @@ impl Vim {
                     self.replace_with_register_object(object, around, window, cx)
                 }
                 Some(Operator::Exchange) => self.exchange_object(object, around, window, cx),
+                Some(Operator::HelixMatch) => {
+                    self.select_current_object(object, around, window, cx)
+                }
                 _ => {
                     // Can't do anything for namespace operators. Ignoring
                 }
             },
+            Some(Operator::HelixNext { around }) => {
+                self.select_next_object(object, around, window, cx);
+            }
+            Some(Operator::HelixPrevious { around }) => {
+                self.select_previous_object(object, around, window, cx);
+            }
             Some(Operator::DeleteSurrounds) => {
                 waiting_operator = Some(Operator::DeleteSurrounds);
             }
diff --git a/crates/vim/src/object.rs b/crates/vim/src/object.rs
index 366acb740bca32f5e191dd22309dd026c0d7ddd3..430149cada78b5deb08f3df551aff480f68ce992 100644
--- a/crates/vim/src/object.rs
+++ b/crates/vim/src/object.rs
@@ -397,11 +397,11 @@ impl Vim {
         let count = Self::take_count(cx);
 
         match self.mode {
-            Mode::Normal => self.normal_object(object, count, window, cx),
+            Mode::Normal | Mode::HelixNormal => self.normal_object(object, count, window, cx),
             Mode::Visual | Mode::VisualLine | Mode::VisualBlock => {
                 self.visual_object(object, count, window, cx)
             }
-            Mode::Insert | Mode::Replace | Mode::HelixNormal => {
+            Mode::Insert | Mode::Replace => {
                 // Shouldn't execute a text object in insert mode. Ignoring
             }
         }
@@ -1364,7 +1364,7 @@ fn is_sentence_end(map: &DisplaySnapshot, offset: usize) -> bool {
 
 /// Expands the passed range to include whitespace on one side or the other in a line. Attempts to add the
 /// whitespace to the end first and falls back to the start if there was none.
-fn expand_to_include_whitespace(
+pub fn expand_to_include_whitespace(
     map: &DisplaySnapshot,
     range: Range<DisplayPoint>,
     stop_at_newline: bool,
diff --git a/crates/vim/src/state.rs b/crates/vim/src/state.rs
index fe4bc7433d57f882b9935cfd547fab6e2eb736c1..8503bffca6ec120f1103fa1dcd72281c092ac941 100644
--- a/crates/vim/src/state.rs
+++ b/crates/vim/src/state.rs
@@ -134,6 +134,13 @@ pub enum Operator {
     ToggleComments,
     ReplaceWithRegister,
     Exchange,
+    HelixMatch,
+    HelixNext {
+        around: bool,
+    },
+    HelixPrevious {
+        around: bool,
+    },
 }
 
 #[derive(Default, Clone, Debug)]
@@ -1020,6 +1027,9 @@ impl Operator {
             Operator::RecordRegister => "q",
             Operator::ReplayRegister => "@",
             Operator::ToggleComments => "gc",
+            Operator::HelixMatch => "helix_m",
+            Operator::HelixNext { .. } => "helix_next",
+            Operator::HelixPrevious { .. } => "helix_previous",
         }
     }
 
@@ -1041,6 +1051,9 @@ impl Operator {
             } => format!("^V{}", make_visible(prefix)),
             Operator::AutoIndent => "=".to_string(),
             Operator::ShellCommand => "=".to_string(),
+            Operator::HelixMatch => "m".to_string(),
+            Operator::HelixNext { .. } => "]".to_string(),
+            Operator::HelixPrevious { .. } => "[".to_string(),
             _ => self.id().to_string(),
         }
     }
@@ -1079,7 +1092,10 @@ impl Operator {
             | Operator::Object { .. }
             | Operator::ChangeSurrounds { target: None }
             | Operator::OppositeCase
-            | Operator::ToggleComments => false,
+            | Operator::ToggleComments
+            | Operator::HelixMatch
+            | Operator::HelixNext { .. }
+            | Operator::HelixPrevious { .. } => false,
         }
     }
 
@@ -1103,7 +1119,9 @@ impl Operator {
             | Operator::AddSurrounds { target: None }
             | Operator::ChangeSurrounds { target: None }
             | Operator::DeleteSurrounds
-            | Operator::Exchange => true,
+            | Operator::Exchange
+            | Operator::HelixNext { .. }
+            | Operator::HelixPrevious { .. } => true,
             Operator::Yank
             | Operator::Object { .. }
             | Operator::FindForward { .. }
@@ -1118,7 +1136,8 @@ impl Operator {
             | Operator::Jump { .. }
             | Operator::Register
             | Operator::RecordRegister
-            | Operator::ReplayRegister => false,
+            | Operator::ReplayRegister
+            | Operator::HelixMatch => false,
         }
     }
 }
diff --git a/crates/vim/src/test/vim_test_context.rs b/crates/vim/src/test/vim_test_context.rs
index ef9588acae181bad2b079d7c89458458bb851a64..4f1173a188b6d3113234c79f02a55d2c34cf12d9 100644
--- a/crates/vim/src/test/vim_test_context.rs
+++ b/crates/vim/src/test/vim_test_context.rs
@@ -68,7 +68,7 @@ impl VimTestContext {
 
     pub fn init_keybindings(enabled: bool, cx: &mut App) {
         SettingsStore::update_global(cx, |store, cx| {
-            store.update_user_settings::<VimModeSetting>(cx, |s| *s = Some(enabled));
+            store.update_user_settings::<VimModeSetting>(cx, |s| s.vim_mode = Some(enabled));
         });
         let default_key_bindings = settings::KeymapFile::load_asset_allow_partial_failure(
             "keymaps/default-macos.json",
@@ -134,7 +134,7 @@ impl VimTestContext {
     pub fn enable_vim(&mut self) {
         self.cx.update(|_, cx| {
             SettingsStore::update_global(cx, |store, cx| {
-                store.update_user_settings::<VimModeSetting>(cx, |s| *s = Some(true));
+                store.update_user_settings::<VimModeSetting>(cx, |s| s.vim_mode = Some(true));
             });
         })
     }
@@ -142,7 +142,7 @@ impl VimTestContext {
     pub fn disable_vim(&mut self) {
         self.cx.update(|_, cx| {
             SettingsStore::update_global(cx, |store, cx| {
-                store.update_user_settings::<VimModeSetting>(cx, |s| *s = Some(false));
+                store.update_user_settings::<VimModeSetting>(cx, |s| s.vim_mode = Some(false));
             });
         })
     }
@@ -151,7 +151,7 @@ impl VimTestContext {
         self.cx.update(|_, cx| {
             SettingsStore::update_global(cx, |store, cx| {
                 store.update_user_settings::<vim_mode_setting::HelixModeSetting>(cx, |s| {
-                    *s = Some(true)
+                    s.helix_mode = Some(true)
                 });
             });
         })
diff --git a/crates/vim/src/vim.rs b/crates/vim/src/vim.rs
index 5a4ac425183e1843db7075c0f5054a16f82948f9..fdf18dfef98c151a6801f2c73336e04df2ac89bb 100644
--- a/crates/vim/src/vim.rs
+++ b/crates/vim/src/vim.rs
@@ -39,7 +39,9 @@ use object::Object;
 use schemars::JsonSchema;
 use serde::Deserialize;
 use serde_derive::Serialize;
-use settings::{Settings, SettingsSources, SettingsStore, SettingsUi, update_settings_file};
+use settings::{
+    Settings, SettingsKey, SettingsSources, SettingsStore, SettingsUi, update_settings_file,
+};
 use state::{Mode, Operator, RecordedSelection, SearchState, VimGlobals};
 use std::{mem, ops::Range, sync::Arc};
 use surrounds::SurroundsType;
@@ -84,6 +86,22 @@ struct PushFindBackward {
     multiline: bool,
 }
 
+#[derive(Clone, Deserialize, JsonSchema, PartialEq, Action)]
+#[action(namespace = vim)]
+#[serde(deny_unknown_fields)]
+/// Selects the next object.
+struct PushHelixNext {
+    around: bool,
+}
+
+#[derive(Clone, Deserialize, JsonSchema, PartialEq, Action)]
+#[action(namespace = vim)]
+#[serde(deny_unknown_fields)]
+/// Selects the previous object.
+struct PushHelixPrevious {
+    around: bool,
+}
+
 #[derive(Clone, Deserialize, JsonSchema, PartialEq, Action)]
 #[action(namespace = vim)]
 #[serde(deny_unknown_fields)]
@@ -222,6 +240,8 @@ actions!(
         PushReplaceWithRegister,
         /// Toggles comments.
         PushToggleComments,
+        /// Starts a match operation.
+        PushHelixMatch,
     ]
 );
 
@@ -247,7 +267,7 @@ pub fn init(cx: &mut App) {
             let fs = workspace.app_state().fs.clone();
             let currently_enabled = Vim::enabled(cx);
             update_settings_file::<VimModeSetting>(fs, cx, move |setting, _| {
-                *setting = Some(!currently_enabled)
+                setting.vim_mode = Some(!currently_enabled)
             })
         });
 
@@ -759,6 +779,27 @@ impl Vim {
             Vim::action(editor, cx, |vim, _: &Enter, window, cx| {
                 vim.input_ignored("\n".into(), window, cx)
             });
+            Vim::action(editor, cx, |vim, _: &PushHelixMatch, window, cx| {
+                vim.push_operator(Operator::HelixMatch, window, cx)
+            });
+            Vim::action(editor, cx, |vim, action: &PushHelixNext, window, cx| {
+                vim.push_operator(
+                    Operator::HelixNext {
+                        around: action.around,
+                    },
+                    window,
+                    cx,
+                );
+            });
+            Vim::action(editor, cx, |vim, action: &PushHelixPrevious, window, cx| {
+                vim.push_operator(
+                    Operator::HelixPrevious {
+                        around: action.around,
+                    },
+                    window,
+                    cx,
+                );
+            });
 
             normal::register(editor, cx);
             insert::register(editor, cx);
@@ -1785,7 +1826,8 @@ struct VimSettings {
     pub cursor_shape: CursorShapeSettings,
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey)]
+#[settings_key(key = "vim")]
 struct VimSettingsContent {
     pub default_mode: Option<ModeContent>,
     pub toggle_relative_line_numbers: Option<bool>,
@@ -1824,8 +1866,6 @@ impl From<ModeContent> for Mode {
 }
 
 impl Settings for VimSettings {
-    const KEY: Option<&'static str> = Some("vim");
-
     type FileContent = VimSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
diff --git a/crates/vim/src/visual.rs b/crates/vim/src/visual.rs
index c62712af311eb09f1203ecb54d939402f936b21c..5fbc04fbee9570db95cc95a4ce023e8e82c3183c 100644
--- a/crates/vim/src/visual.rs
+++ b/crates/vim/src/visual.rs
@@ -53,6 +53,10 @@ actions!(
         SelectSmallerSyntaxNode,
         /// Selects the next larger syntax node.
         SelectLargerSyntaxNode,
+        /// Selects the next syntax node sibling.
+        SelectNextSyntaxNode,
+        /// Selects the previous syntax node sibling.
+        SelectPreviousSyntaxNode,
         /// Restores the previous visual selection.
         RestoreVisualSelection,
         /// Inserts at the end of each line in visual selection.
@@ -110,6 +114,30 @@ pub fn register(editor: &mut Editor, cx: &mut Context<Vim>) {
         }
     });
 
+    Vim::action(editor, cx, |vim, _: &SelectNextSyntaxNode, window, cx| {
+        let count = Vim::take_count(cx).unwrap_or(1);
+        Vim::take_forced_motion(cx);
+        for _ in 0..count {
+            vim.update_editor(cx, |_, editor, cx| {
+                editor.select_next_syntax_node(&Default::default(), window, cx);
+            });
+        }
+    });
+
+    Vim::action(
+        editor,
+        cx,
+        |vim, _: &SelectPreviousSyntaxNode, window, cx| {
+            let count = Vim::take_count(cx).unwrap_or(1);
+            Vim::take_forced_motion(cx);
+            for _ in 0..count {
+                vim.update_editor(cx, |_, editor, cx| {
+                    editor.select_prev_syntax_node(&Default::default(), window, cx);
+                });
+            }
+        },
+    );
+
     Vim::action(
         editor,
         cx,
@@ -1839,4 +1867,37 @@ mod test {
             fˇ»ox"
         });
     }
+
+    #[gpui::test]
+    async fn test_visual_syntax_sibling_selection(cx: &mut gpui::TestAppContext) {
+        let mut cx = VimTestContext::new(cx, true).await;
+
+        cx.set_state(
+            indoc! {"
+                fn test() {
+                    let ˇa = 1;
+                    let b = 2;
+                    let c = 3;
+                }
+            "},
+            Mode::Normal,
+        );
+
+        // Enter visual mode and select the statement
+        cx.simulate_keystrokes("v w w w");
+        cx.assert_state(
+            indoc! {"
+                fn test() {
+                    let «a = 1;ˇ»
+                    let b = 2;
+                    let c = 3;
+                }
+            "},
+            Mode::Visual,
+        );
+
+        // The specific behavior of syntax sibling selection in vim mode
+        // would depend on the key bindings configured, but the actions
+        // are now available for use
+    }
 }
diff --git a/crates/vim_mode_setting/Cargo.toml b/crates/vim_mode_setting/Cargo.toml
index fbb7f30b4c2a03aca48ad5db26283c33aedb885b..61d265b958b10fac700bd78577ac5fefb19b7d09 100644
--- a/crates/vim_mode_setting/Cargo.toml
+++ b/crates/vim_mode_setting/Cargo.toml
@@ -14,5 +14,7 @@ path = "src/vim_mode_setting.rs"
 [dependencies]
 anyhow.workspace = true
 gpui.workspace = true
+schemars.workspace = true
+serde.workspace = true
 settings.workspace = true
 workspace-hack.workspace = true
diff --git a/crates/vim_mode_setting/src/vim_mode_setting.rs b/crates/vim_mode_setting/src/vim_mode_setting.rs
index 7fb39ef4f6f10370f1a0fb2cf83dcb3a88b80d81..660520a307dbef1e73174aa5449417d766c04235 100644
--- a/crates/vim_mode_setting/src/vim_mode_setting.rs
+++ b/crates/vim_mode_setting/src/vim_mode_setting.rs
@@ -6,7 +6,8 @@
 
 use anyhow::Result;
 use gpui::App;
-use settings::{Settings, SettingsSources, SettingsUi};
+use schemars::JsonSchema;
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 
 /// Initializes the `vim_mode_setting` crate.
 pub fn init(cx: &mut App) {
@@ -14,25 +15,40 @@ pub fn init(cx: &mut App) {
     HelixModeSetting::register(cx);
 }
 
-/// Whether or not to enable Vim mode.
-///
-/// Default: false
-#[derive(SettingsUi)]
 pub struct VimModeSetting(pub bool);
 
-impl Settings for VimModeSetting {
-    const KEY: Option<&'static str> = Some("vim_mode");
+#[derive(
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    Debug,
+    Default,
+    serde::Serialize,
+    serde::Deserialize,
+    SettingsUi,
+    SettingsKey,
+    JsonSchema,
+)]
+#[settings_key(None)]
+pub struct VimModeSettingContent {
+    /// Whether or not to enable Vim mode.
+    ///
+    /// Default: false
+    pub vim_mode: Option<bool>,
+}
 
-    type FileContent = Option<bool>;
+impl Settings for VimModeSetting {
+    type FileContent = VimModeSettingContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
         Ok(Self(
             sources
                 .user
-                .or(sources.server)
-                .copied()
-                .flatten()
-                .unwrap_or(sources.default.ok_or_else(Self::missing_default)?),
+                .and_then(|mode| mode.vim_mode)
+                .or(sources.server.and_then(|mode| mode.vim_mode))
+                .or(sources.default.vim_mode)
+                .ok_or_else(Self::missing_default)?,
         ))
     }
 
@@ -41,25 +57,41 @@ impl Settings for VimModeSetting {
     }
 }
 
-/// Whether or not to enable Helix mode.
-///
-/// Default: false
-#[derive(SettingsUi)]
+#[derive(Debug)]
 pub struct HelixModeSetting(pub bool);
 
-impl Settings for HelixModeSetting {
-    const KEY: Option<&'static str> = Some("helix_mode");
+#[derive(
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    Debug,
+    Default,
+    serde::Serialize,
+    serde::Deserialize,
+    SettingsUi,
+    SettingsKey,
+    JsonSchema,
+)]
+#[settings_key(None)]
+pub struct HelixModeSettingContent {
+    /// Whether or not to enable Helix mode.
+    ///
+    /// Default: false
+    pub helix_mode: Option<bool>,
+}
 
-    type FileContent = Option<bool>;
+impl Settings for HelixModeSetting {
+    type FileContent = HelixModeSettingContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
         Ok(Self(
             sources
                 .user
-                .or(sources.server)
-                .copied()
-                .flatten()
-                .unwrap_or(sources.default.ok_or_else(Self::missing_default)?),
+                .and_then(|mode| mode.helix_mode)
+                .or(sources.server.and_then(|mode| mode.helix_mode))
+                .or(sources.default.helix_mode)
+                .ok_or_else(Self::missing_default)?,
         ))
     }
 
diff --git a/crates/workspace/src/invalid_buffer_view.rs b/crates/workspace/src/invalid_buffer_view.rs
index b8c0db29d3ab95497fc5e850b0738b762f42b28b..05f409653b69e76654fa11d70b57d61fd6c0b73b 100644
--- a/crates/workspace/src/invalid_buffer_view.rs
+++ b/crates/workspace/src/invalid_buffer_view.rs
@@ -3,7 +3,8 @@ use std::{path::Path, sync::Arc};
 use gpui::{EventEmitter, FocusHandle, Focusable};
 use ui::{
     App, Button, ButtonCommon, ButtonStyle, Clickable, Context, FluentBuilder, InteractiveElement,
-    KeyBinding, ParentElement, Render, SharedString, Styled as _, Window, h_flex, v_flex,
+    KeyBinding, Label, LabelCommon, LabelSize, ParentElement, Render, SharedString, Styled as _,
+    Window, h_flex, v_flex,
 };
 use zed_actions::workspace::OpenWithSystem;
 
@@ -30,7 +31,7 @@ impl InvalidBufferView {
         Self {
             is_local,
             abs_path: Arc::from(abs_path),
-            error: format!("{e}").into(),
+            error: format!("{}", e.root_cause()).into(),
             focus_handle: cx.focus_handle(),
         }
     }
@@ -88,7 +89,12 @@ impl Render for InvalidBufferView {
                     v_flex()
                         .justify_center()
                         .gap_2()
-                        .child(h_flex().justify_center().child("Unsupported file type"))
+                        .child(h_flex().justify_center().child("Could not open file"))
+                        .child(
+                            h_flex()
+                                .justify_center()
+                                .child(Label::new(self.error.clone()).size(LabelSize::Small)),
+                        )
                         .when(self.is_local, |contents| {
                             contents.child(
                                 h_flex().justify_center().child(
diff --git a/crates/workspace/src/item.rs b/crates/workspace/src/item.rs
index f37be0f154f736b021b0fcf5f29cf26074e3299f..23fbec470c4d2e305bf7b51679bbe56f6dfeaa95 100644
--- a/crates/workspace/src/item.rs
+++ b/crates/workspace/src/item.rs
@@ -17,7 +17,7 @@ use gpui::{
 use project::{Project, ProjectEntryId, ProjectPath};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsLocation, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsLocation, SettingsSources, SettingsUi};
 use smallvec::SmallVec;
 use std::{
     any::{Any, TypeId},
@@ -101,7 +101,8 @@ pub enum ActivateOnClose {
     LeftNeighbour,
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey)]
+#[settings_key(key = "tabs")]
 pub struct ItemSettingsContent {
     /// Whether to show the Git file status on a tab item.
     ///
@@ -130,7 +131,8 @@ pub struct ItemSettingsContent {
     show_close_button: Option<ShowCloseButton>,
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey)]
+#[settings_key(key = "preview_tabs")]
 pub struct PreviewTabsSettingsContent {
     /// Whether to show opened editors as preview tabs.
     /// Preview tabs do not stay open, are reused until explicitly set to be kept open opened (via double-click or editing) and show file names in italic.
@@ -148,8 +150,6 @@ pub struct PreviewTabsSettingsContent {
 }
 
 impl Settings for ItemSettings {
-    const KEY: Option<&'static str> = Some("tabs");
-
     type FileContent = ItemSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
@@ -187,8 +187,6 @@ impl Settings for ItemSettings {
 }
 
 impl Settings for PreviewTabsSettings {
-    const KEY: Option<&'static str> = Some("preview_tabs");
-
     type FileContent = PreviewTabsSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
diff --git a/crates/workspace/src/persistence.rs b/crates/workspace/src/persistence.rs
index ef5a86a2762510fbea6f6a1a5172953a0ea20f7d..797c4796830ff767a0213058c417bb3a764c6bec 100644
--- a/crates/workspace/src/persistence.rs
+++ b/crates/workspace/src/persistence.rs
@@ -9,7 +9,7 @@ use std::{
 };
 
 use anyhow::{Context as _, Result, bail};
-use collections::HashMap;
+use collections::{HashMap, IndexSet};
 use db::{
     query,
     sqlez::{connection::Connection, domain::Domain},
@@ -18,16 +18,16 @@ use db::{
 use gpui::{Axis, Bounds, Task, WindowBounds, WindowId, point, size};
 use project::debugger::breakpoint_store::{BreakpointState, SourceBreakpoint};
 
-use language::{LanguageName, Toolchain};
+use language::{LanguageName, Toolchain, ToolchainScope};
 use project::WorktreeId;
 use remote::{RemoteConnectionOptions, SshConnectionOptions, WslConnectionOptions};
 use sqlez::{
     bindable::{Bind, Column, StaticColumnCount},
-    statement::{SqlType, Statement},
+    statement::Statement,
     thread_safe_connection::ThreadSafeConnection,
 };
 
-use ui::{App, px};
+use ui::{App, SharedString, px};
 use util::{ResultExt, maybe};
 use uuid::Uuid;
 
@@ -169,6 +169,7 @@ impl From<BreakpointState> for BreakpointStateWrapper<'static> {
         BreakpointStateWrapper(Cow::Owned(kind))
     }
 }
+
 impl StaticColumnCount for BreakpointStateWrapper<'_> {
     fn column_count() -> usize {
         1
@@ -193,11 +194,6 @@ impl Column for BreakpointStateWrapper<'_> {
     }
 }
 
-/// This struct is used to implement traits on Vec<breakpoint>
-#[derive(Debug)]
-#[allow(dead_code)]
-struct Breakpoints(Vec<Breakpoint>);
-
 impl sqlez::bindable::StaticColumnCount for Breakpoint {
     fn column_count() -> usize {
         // Position, log message, condition message, and hit condition message
@@ -246,26 +242,6 @@ impl Column for Breakpoint {
     }
 }
 
-impl Column for Breakpoints {
-    fn column(statement: &mut Statement, start_index: i32) -> Result<(Self, i32)> {
-        let mut breakpoints = Vec::new();
-        let mut index = start_index;
-
-        loop {
-            match statement.column_type(index) {
-                Ok(SqlType::Null) => break,
-                _ => {
-                    let (breakpoint, next_index) = Breakpoint::column(statement, index)?;
-
-                    breakpoints.push(breakpoint);
-                    index = next_index;
-                }
-            }
-        }
-        Ok((Breakpoints(breakpoints), index))
-    }
-}
-
 #[derive(Clone, Debug, PartialEq)]
 struct SerializedPixels(gpui::Pixels);
 impl sqlez::bindable::StaticColumnCount for SerializedPixels {}
@@ -711,6 +687,21 @@ impl Domain for WorkspaceDb {
 
             CREATE UNIQUE INDEX ix_workspaces_location ON workspaces(remote_connection_id, paths);
         ),
+        sql!(CREATE TABLE user_toolchains (
+            remote_connection_id INTEGER,
+            workspace_id INTEGER NOT NULL,
+            worktree_id INTEGER NOT NULL,
+            relative_worktree_path TEXT NOT NULL,
+            language_name TEXT NOT NULL,
+            name TEXT NOT NULL,
+            path TEXT NOT NULL,
+            raw_json TEXT NOT NULL,
+
+            PRIMARY KEY (workspace_id, worktree_id, relative_worktree_path, language_name, name, path, raw_json)
+        ) STRICT;),
+        sql!(
+            DROP TABLE ssh_connections;
+        ),
     ];
 
     // Allow recovering from bad migration that was initially shipped to nightly
@@ -831,6 +822,7 @@ impl WorkspaceDb {
             session_id: None,
             breakpoints: self.breakpoints(workspace_id),
             window_id,
+            user_toolchains: self.user_toolchains(workspace_id, remote_connection_id),
         })
     }
 
@@ -880,6 +872,73 @@ impl WorkspaceDb {
         }
     }
 
+    fn user_toolchains(
+        &self,
+        workspace_id: WorkspaceId,
+        remote_connection_id: Option<RemoteConnectionId>,
+    ) -> BTreeMap<ToolchainScope, IndexSet<Toolchain>> {
+        type RowKind = (WorkspaceId, u64, String, String, String, String, String);
+
+        let toolchains: Vec<RowKind> = self
+            .select_bound(sql! {
+                SELECT workspace_id, worktree_id, relative_worktree_path,
+                language_name, name, path, raw_json
+                FROM user_toolchains WHERE remote_connection_id IS ?1 AND (
+                      workspace_id IN (0, ?2)
+                )
+            })
+            .and_then(|mut statement| {
+                (statement)((remote_connection_id.map(|id| id.0), workspace_id))
+            })
+            .unwrap_or_default();
+        let mut ret = BTreeMap::<_, IndexSet<_>>::default();
+
+        for (
+            _workspace_id,
+            worktree_id,
+            relative_worktree_path,
+            language_name,
+            name,
+            path,
+            raw_json,
+        ) in toolchains
+        {
+            // INTEGER's that are primary keys (like workspace ids, remote connection ids and such) start at 1, so we're safe to
+            let scope = if _workspace_id == WorkspaceId(0) {
+                debug_assert_eq!(worktree_id, u64::MAX);
+                debug_assert_eq!(relative_worktree_path, String::default());
+                ToolchainScope::Global
+            } else {
+                debug_assert_eq!(workspace_id, _workspace_id);
+                debug_assert_eq!(
+                    worktree_id == u64::MAX,
+                    relative_worktree_path == String::default()
+                );
+
+                if worktree_id != u64::MAX && relative_worktree_path != String::default() {
+                    ToolchainScope::Subproject(
+                        WorktreeId::from_usize(worktree_id as usize),
+                        Arc::from(relative_worktree_path.as_ref()),
+                    )
+                } else {
+                    ToolchainScope::Project
+                }
+            };
+            let Ok(as_json) = serde_json::from_str(&raw_json) else {
+                continue;
+            };
+            let toolchain = Toolchain {
+                name: SharedString::from(name),
+                path: SharedString::from(path),
+                language_name: LanguageName::from_proto(language_name),
+                as_json,
+            };
+            ret.entry(scope).or_default().insert(toolchain);
+        }
+
+        ret
+    }
+
     /// Saves a workspace using the worktree roots. Will garbage collect any workspaces
     /// that used this workspace previously
     pub(crate) async fn save_workspace(&self, workspace: SerializedWorkspace) {
@@ -935,6 +994,22 @@ impl WorkspaceDb {
                         }
                     }
                 }
+                for (scope, toolchains) in workspace.user_toolchains {
+                    for toolchain in toolchains {
+                        let query = sql!(INSERT OR REPLACE INTO user_toolchains(remote_connection_id, workspace_id, worktree_id, relative_worktree_path, language_name, name, path, raw_json) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8));
+                        let (workspace_id, worktree_id, relative_worktree_path) = match scope {
+                            ToolchainScope::Subproject(worktree_id, ref path) => (Some(workspace.id), Some(worktree_id), Some(path.to_string_lossy().into_owned())),
+                            ToolchainScope::Project => (Some(workspace.id), None, None),
+                            ToolchainScope::Global => (None, None, None),
+                        };
+                        let args = (remote_connection_id, workspace_id.unwrap_or(WorkspaceId(0)), worktree_id.map_or(usize::MAX,|id| id.to_usize()), relative_worktree_path.unwrap_or_default(),
+                        toolchain.language_name.as_ref().to_owned(), toolchain.name.to_string(), toolchain.path.to_string(), toolchain.as_json.to_string());
+                        if let Err(err) = conn.exec_bound(query)?(args) {
+                            log::error!("{err}");
+                            continue;
+                        }
+                    }
+                }
 
                 conn.exec_bound(sql!(
                     DELETE
@@ -1797,6 +1872,7 @@ mod tests {
             },
             session_id: None,
             window_id: None,
+            user_toolchains: Default::default(),
         };
 
         db.save_workspace(workspace.clone()).await;
@@ -1917,6 +1993,7 @@ mod tests {
             },
             session_id: None,
             window_id: None,
+            user_toolchains: Default::default(),
         };
 
         db.save_workspace(workspace.clone()).await;
@@ -1950,6 +2027,7 @@ mod tests {
             breakpoints: collections::BTreeMap::default(),
             session_id: None,
             window_id: None,
+            user_toolchains: Default::default(),
         };
 
         db.save_workspace(workspace_without_breakpoint.clone())
@@ -2047,6 +2125,7 @@ mod tests {
             breakpoints: Default::default(),
             session_id: None,
             window_id: None,
+            user_toolchains: Default::default(),
         };
 
         let workspace_2 = SerializedWorkspace {
@@ -2061,6 +2140,7 @@ mod tests {
             breakpoints: Default::default(),
             session_id: None,
             window_id: None,
+            user_toolchains: Default::default(),
         };
 
         db.save_workspace(workspace_1.clone()).await;
@@ -2167,6 +2247,7 @@ mod tests {
             centered_layout: false,
             session_id: None,
             window_id: Some(999),
+            user_toolchains: Default::default(),
         };
 
         db.save_workspace(workspace.clone()).await;
@@ -2200,6 +2281,7 @@ mod tests {
             centered_layout: false,
             session_id: None,
             window_id: Some(1),
+            user_toolchains: Default::default(),
         };
 
         let mut workspace_2 = SerializedWorkspace {
@@ -2214,6 +2296,7 @@ mod tests {
             breakpoints: Default::default(),
             session_id: None,
             window_id: Some(2),
+            user_toolchains: Default::default(),
         };
 
         db.save_workspace(workspace_1.clone()).await;
@@ -2255,6 +2338,7 @@ mod tests {
             centered_layout: false,
             session_id: None,
             window_id: Some(3),
+            user_toolchains: Default::default(),
         };
 
         db.save_workspace(workspace_3.clone()).await;
@@ -2292,6 +2376,7 @@ mod tests {
             breakpoints: Default::default(),
             session_id: Some("session-id-1".to_owned()),
             window_id: Some(10),
+            user_toolchains: Default::default(),
         };
 
         let workspace_2 = SerializedWorkspace {
@@ -2306,6 +2391,7 @@ mod tests {
             breakpoints: Default::default(),
             session_id: Some("session-id-1".to_owned()),
             window_id: Some(20),
+            user_toolchains: Default::default(),
         };
 
         let workspace_3 = SerializedWorkspace {
@@ -2320,6 +2406,7 @@ mod tests {
             breakpoints: Default::default(),
             session_id: Some("session-id-2".to_owned()),
             window_id: Some(30),
+            user_toolchains: Default::default(),
         };
 
         let workspace_4 = SerializedWorkspace {
@@ -2334,6 +2421,7 @@ mod tests {
             breakpoints: Default::default(),
             session_id: None,
             window_id: None,
+            user_toolchains: Default::default(),
         };
 
         let connection_id = db
@@ -2359,6 +2447,7 @@ mod tests {
             breakpoints: Default::default(),
             session_id: Some("session-id-2".to_owned()),
             window_id: Some(50),
+            user_toolchains: Default::default(),
         };
 
         let workspace_6 = SerializedWorkspace {
@@ -2373,6 +2462,7 @@ mod tests {
             centered_layout: false,
             session_id: Some("session-id-3".to_owned()),
             window_id: Some(60),
+            user_toolchains: Default::default(),
         };
 
         db.save_workspace(workspace_1.clone()).await;
@@ -2424,6 +2514,7 @@ mod tests {
             centered_layout: false,
             session_id: None,
             window_id: None,
+            user_toolchains: Default::default(),
         }
     }
 
@@ -2458,6 +2549,7 @@ mod tests {
             session_id: Some("one-session".to_owned()),
             breakpoints: Default::default(),
             window_id: Some(window_id),
+            user_toolchains: Default::default(),
         })
         .collect::<Vec<_>>();
 
@@ -2555,6 +2647,7 @@ mod tests {
             session_id: Some("one-session".to_owned()),
             breakpoints: Default::default(),
             window_id: Some(window_id),
+            user_toolchains: Default::default(),
         })
         .collect::<Vec<_>>();
 
diff --git a/crates/workspace/src/persistence/model.rs b/crates/workspace/src/persistence/model.rs
index 005a1ba2347f8ac3847199ad4564d8ca45420f4a..08a2f2e38dd142848f8a9c07652e147b58bee233 100644
--- a/crates/workspace/src/persistence/model.rs
+++ b/crates/workspace/src/persistence/model.rs
@@ -5,12 +5,14 @@ use crate::{
 };
 use anyhow::Result;
 use async_recursion::async_recursion;
+use collections::IndexSet;
 use db::sqlez::{
     bindable::{Bind, Column, StaticColumnCount},
     statement::Statement,
 };
 use gpui::{AsyncWindowContext, Entity, WeakEntity};
 
+use language::{Toolchain, ToolchainScope};
 use project::{Project, debugger::breakpoint_store::SourceBreakpoint};
 use remote::RemoteConnectionOptions;
 use std::{
@@ -57,6 +59,7 @@ pub(crate) struct SerializedWorkspace {
     pub(crate) docks: DockStructure,
     pub(crate) session_id: Option<String>,
     pub(crate) breakpoints: BTreeMap<Arc<Path>, Vec<SourceBreakpoint>>,
+    pub(crate) user_toolchains: BTreeMap<ToolchainScope, IndexSet<Toolchain>>,
     pub(crate) window_id: Option<u64>,
 }
 
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index af86517bb452c1cea77a72f2cf2350ef1e2eb030..58373b5d1a30a431106282d26589aa09694d3382 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -73,6 +73,7 @@ use postage::stream::Stream;
 use project::{
     DirectoryLister, Project, ProjectEntryId, ProjectPath, ResolvedPath, Worktree, WorktreeId,
     debugger::{breakpoint_store::BreakpointStoreEvent, session::ThreadStatus},
+    toolchain_store::ToolchainStoreEvent,
 };
 use remote::{RemoteClientDelegate, RemoteConnectionOptions, remote_client::ConnectionIdentifier};
 use schemars::JsonSchema;
@@ -1031,6 +1032,9 @@ pub enum Event {
         item: Box<dyn ItemHandle>,
     },
     ActiveItemChanged,
+    ItemRemoved {
+        item_id: EntityId,
+    },
     UserSavedItem {
         pane: WeakEntity<Pane>,
         item: Box<dyn WeakItemHandle>,
@@ -1272,6 +1276,19 @@ impl Workspace {
             },
         )
         .detach();
+        if let Some(toolchain_store) = project.read(cx).toolchain_store() {
+            cx.subscribe_in(
+                &toolchain_store,
+                window,
+                |workspace, _, event, window, cx| match event {
+                    ToolchainStoreEvent::CustomToolchainsModified => {
+                        workspace.serialize_workspace(window, cx);
+                    }
+                    _ => {}
+                },
+            )
+            .detach();
+        }
 
         cx.on_focus_lost(window, |this, window, cx| {
             let focus_handle = this.focus_handle(cx);
@@ -1562,6 +1579,16 @@ impl Workspace {
                     })?
                     .await;
             }
+            if let Some(workspace) = serialized_workspace.as_ref() {
+                project_handle.update(cx, |this, cx| {
+                    for (scope, toolchains) in &workspace.user_toolchains {
+                        for toolchain in toolchains {
+                            this.add_toolchain(toolchain.clone(), scope.clone(), cx);
+                        }
+                    }
+                })?;
+            }
+
             let window = if let Some(window) = requesting_window {
                 let centered_layout = serialized_workspace
                     .as_ref()
@@ -3090,6 +3117,16 @@ impl Workspace {
         }
     }
 
+    pub fn close_panel<T: Panel>(&self, window: &mut Window, cx: &mut Context<Self>) {
+        for dock in self.all_docks().iter() {
+            dock.update(cx, |dock, cx| {
+                if dock.panel::<T>().is_some() {
+                    dock.set_open(false, window, cx)
+                }
+            })
+        }
+    }
+
     pub fn panel<T: Panel>(&self, cx: &App) -> Option<Entity<T>> {
         self.all_docks()
             .iter()
@@ -3945,6 +3982,9 @@ impl Workspace {
                 {
                     entry.remove();
                 }
+                cx.emit(Event::ItemRemoved {
+                    item_id: item.item_id(),
+                });
             }
             pane::Event::Focus => {
                 window.invalidate_character_coordinates();
@@ -5224,10 +5264,16 @@ impl Workspace {
                         .read(cx)
                         .all_source_breakpoints(cx)
                 });
+                let user_toolchains = self
+                    .project
+                    .read(cx)
+                    .user_toolchains(cx)
+                    .unwrap_or_default();
 
                 let center_group = build_serialized_pane_group(&self.center.root, window, cx);
                 let docks = build_serialized_docks(self, window, cx);
                 let window_bounds = Some(SerializedWindowBounds(window.window_bounds()));
+
                 let serialized_workspace = SerializedWorkspace {
                     id: database_id,
                     location,
@@ -5240,6 +5286,7 @@ impl Workspace {
                     session_id: self.session_id.clone(),
                     breakpoints,
                     window_id: Some(window.window_handle().window_id().as_u64()),
+                    user_toolchains,
                 };
 
                 window.spawn(cx, async move |_| {
diff --git a/crates/workspace/src/workspace_settings.rs b/crates/workspace/src/workspace_settings.rs
index 1a7e548e4eda1f41e36c6ad0883cdd57be8828d7..8868f3190575ac4b861e0619732890f477d83b69 100644
--- a/crates/workspace/src/workspace_settings.rs
+++ b/crates/workspace/src/workspace_settings.rs
@@ -6,7 +6,7 @@ use collections::HashMap;
 use gpui::App;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 
 #[derive(Deserialize)]
 pub struct WorkspaceSettings {
@@ -118,7 +118,8 @@ pub enum RestoreOnStartupBehavior {
     LastSession,
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey)]
+#[settings_key(None)]
 pub struct WorkspaceSettingsContent {
     /// Active pane styling settings.
     pub active_pane_modifiers: Option<ActivePanelModifiers>,
@@ -223,7 +224,8 @@ pub struct TabBarSettings {
     pub show_tab_bar_buttons: bool,
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey)]
+#[settings_key(key = "tab_bar")]
 pub struct TabBarSettingsContent {
     /// Whether or not to show the tab bar in the editor.
     ///
@@ -282,8 +284,6 @@ pub struct CenteredLayoutSettings {
 }
 
 impl Settings for WorkspaceSettings {
-    const KEY: Option<&'static str> = None;
-
     type FileContent = WorkspaceSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
@@ -373,8 +373,6 @@ impl Settings for WorkspaceSettings {
 }
 
 impl Settings for TabBarSettings {
-    const KEY: Option<&'static str> = Some("tab_bar");
-
     type FileContent = TabBarSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self> {
diff --git a/crates/worktree/src/worktree_settings.rs b/crates/worktree/src/worktree_settings.rs
index 6a8e2b5d89b0201b81f45817adb439fe85e24d91..41eb3ab6f6aa971d44009c1cbb00567a4f3448ea 100644
--- a/crates/worktree/src/worktree_settings.rs
+++ b/crates/worktree/src/worktree_settings.rs
@@ -4,7 +4,7 @@ use anyhow::Context as _;
 use gpui::App;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
 use util::paths::PathMatcher;
 
 #[derive(Clone, PartialEq, Eq)]
@@ -31,7 +31,8 @@ impl WorktreeSettings {
     }
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey)]
+#[settings_key(None)]
 pub struct WorktreeSettingsContent {
     /// Completely ignore files matching globs from `file_scan_exclusions`. Overrides
     /// `file_scan_inclusions`.
@@ -65,8 +66,6 @@ pub struct WorktreeSettingsContent {
 }
 
 impl Settings for WorktreeSettings {
-    const KEY: Option<&'static str> = None;
-
     type FileContent = WorktreeSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> anyhow::Result<Self> {
diff --git a/crates/worktree/src/worktree_tests.rs b/crates/worktree/src/worktree_tests.rs
index 1783ba317c9927bb79ebdb91b1f57f13d200b60f..92569e0f8177ea2886271e2a39580076effc4e8b 100644
--- a/crates/worktree/src/worktree_tests.rs
+++ b/crates/worktree/src/worktree_tests.rs
@@ -1464,7 +1464,7 @@ async fn test_random_worktree_operations_during_initial_scan(
             tree.as_local().unwrap().snapshot().check_invariants(true)
         });
 
-        if rng.gen_bool(0.6) {
+        if rng.random_bool(0.6) {
             snapshots.push(worktree.read_with(cx, |tree, _| tree.as_local().unwrap().snapshot()));
         }
     }
@@ -1551,7 +1551,7 @@ async fn test_random_worktree_changes(cx: &mut TestAppContext, mut rng: StdRng)
     let mut snapshots = Vec::new();
     let mut mutations_len = operations;
     while mutations_len > 1 {
-        if rng.gen_bool(0.2) {
+        if rng.random_bool(0.2) {
             worktree
                 .update(cx, |worktree, cx| {
                     randomly_mutate_worktree(worktree, &mut rng, cx)
@@ -1563,8 +1563,8 @@ async fn test_random_worktree_changes(cx: &mut TestAppContext, mut rng: StdRng)
         }
 
         let buffered_event_count = fs.as_fake().buffered_event_count();
-        if buffered_event_count > 0 && rng.gen_bool(0.3) {
-            let len = rng.gen_range(0..=buffered_event_count);
+        if buffered_event_count > 0 && rng.random_bool(0.3) {
+            let len = rng.random_range(0..=buffered_event_count);
             log::info!("flushing {} events", len);
             fs.as_fake().flush_events(len);
         } else {
@@ -1573,7 +1573,7 @@ async fn test_random_worktree_changes(cx: &mut TestAppContext, mut rng: StdRng)
         }
 
         cx.executor().run_until_parked();
-        if rng.gen_bool(0.2) {
+        if rng.random_bool(0.2) {
             log::info!("storing snapshot {}", snapshots.len());
             let snapshot = worktree.read_with(cx, |tree, _| tree.as_local().unwrap().snapshot());
             snapshots.push(snapshot);
@@ -1701,7 +1701,7 @@ fn randomly_mutate_worktree(
     let snapshot = worktree.snapshot();
     let entry = snapshot.entries(false, 0).choose(rng).unwrap();
 
-    match rng.gen_range(0_u32..100) {
+    match rng.random_range(0_u32..100) {
         0..=33 if entry.path.as_ref() != Path::new("") => {
             log::info!("deleting entry {:?} ({})", entry.path, entry.id.0);
             worktree.delete_entry(entry.id, false, cx).unwrap()
@@ -1733,7 +1733,7 @@ fn randomly_mutate_worktree(
         _ => {
             if entry.is_dir() {
                 let child_path = entry.path.join(random_filename(rng));
-                let is_dir = rng.gen_bool(0.3);
+                let is_dir = rng.random_bool(0.3);
                 log::info!(
                     "creating {} at {:?}",
                     if is_dir { "dir" } else { "file" },
@@ -1776,11 +1776,11 @@ async fn randomly_mutate_fs(
         }
     }
 
-    if (files.is_empty() && dirs.len() == 1) || rng.gen_bool(insertion_probability) {
+    if (files.is_empty() && dirs.len() == 1) || rng.random_bool(insertion_probability) {
         let path = dirs.choose(rng).unwrap();
         let new_path = path.join(random_filename(rng));
 
-        if rng.r#gen() {
+        if rng.random() {
             log::info!(
                 "creating dir {:?}",
                 new_path.strip_prefix(root_path).unwrap()
@@ -1793,7 +1793,7 @@ async fn randomly_mutate_fs(
             );
             fs.create_file(&new_path, Default::default()).await.unwrap();
         }
-    } else if rng.gen_bool(0.05) {
+    } else if rng.random_bool(0.05) {
         let ignore_dir_path = dirs.choose(rng).unwrap();
         let ignore_path = ignore_dir_path.join(*GITIGNORE);
 
@@ -1808,11 +1808,11 @@ async fn randomly_mutate_fs(
             .cloned()
             .collect::<Vec<_>>();
         let files_to_ignore = {
-            let len = rng.gen_range(0..=subfiles.len());
+            let len = rng.random_range(0..=subfiles.len());
             subfiles.choose_multiple(rng, len)
         };
         let dirs_to_ignore = {
-            let len = rng.gen_range(0..subdirs.len());
+            let len = rng.random_range(0..subdirs.len());
             subdirs.choose_multiple(rng, len)
         };
 
@@ -1848,7 +1848,7 @@ async fn randomly_mutate_fs(
             file_path.into_iter().chain(dir_path).choose(rng).unwrap()
         };
 
-        let is_rename = rng.r#gen();
+        let is_rename = rng.random();
         if is_rename {
             let new_path_parent = dirs
                 .iter()
@@ -1857,7 +1857,7 @@ async fn randomly_mutate_fs(
                 .unwrap();
 
             let overwrite_existing_dir =
-                !old_path.starts_with(new_path_parent) && rng.gen_bool(0.3);
+                !old_path.starts_with(new_path_parent) && rng.random_bool(0.3);
             let new_path = if overwrite_existing_dir {
                 fs.remove_dir(
                     new_path_parent,
@@ -1919,7 +1919,7 @@ async fn randomly_mutate_fs(
 
 fn random_filename(rng: &mut impl Rng) -> String {
     (0..6)
-        .map(|_| rng.sample(rand::distributions::Alphanumeric))
+        .map(|_| rng.sample(rand::distr::Alphanumeric))
         .map(char::from)
         .collect()
 }
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index f2295d5fa732d9e36e2b37cf346199f35cabc803..4341a77fc771f5d887847a3f091ce73c08464112 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -24,7 +24,6 @@ acp_tools.workspace = true
 agent.workspace = true
 agent_ui.workspace = true
 agent_settings.workspace = true
-agent_servers.workspace = true
 anyhow.workspace = true
 askpass.workspace = true
 assets.workspace = true
@@ -90,9 +89,11 @@ language.workspace = true
 language_extension.workspace = true
 language_model.workspace = true
 language_models.workspace = true
+language_onboarding.workspace = true
 language_selector.workspace = true
 language_tools.workspace = true
 languages = { workspace = true, features = ["load-grammars"] }
+line_ending_selector.workspace = true
 libc.workspace = true
 log.workspace = true
 markdown.workspace = true
diff --git a/crates/zed/resources/windows/zed-wsl b/crates/zed/resources/windows/zed.sh
similarity index 88%
rename from crates/zed/resources/windows/zed-wsl
rename to crates/zed/resources/windows/zed.sh
index d3cbb93af6f5979508229656deadeab0dbf21661..734b1a7eb00dc304786a58674171fdb5872b90c8 100644
--- a/crates/zed/resources/windows/zed-wsl
+++ b/crates/zed/resources/windows/zed.sh
@@ -20,6 +20,6 @@ if [ $IN_WSL = true ]; then
     "$ZED_PATH/zed.exe" --wsl "$WSL_USER@$WSL_DISTRO_NAME" "$@"
     exit $?
 else
-    echo "Only WSL is supported for now" >&2
-    exit 1
+    "$ZED_PATH/zed.exe" "$@"
+    exit $?
 fi
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index 9582e7a2ab541243a768370eb08ed1f4f1c465a3..b5fc8943eb6116016de14844f719c55e7abe7193 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -567,7 +567,6 @@ pub fn main() {
         language_model::init(app_state.client.clone(), cx);
         language_models::init(app_state.user_store.clone(), app_state.client.clone(), cx);
         agent_settings::init(cx);
-        agent_servers::init(cx);
         acp_tools::init(cx);
         web_search::init(cx);
         web_search_providers::init(app_state.client.clone(), cx);
@@ -620,6 +619,7 @@ pub fn main() {
         terminal_view::init(cx);
         journal::init(app_state.clone(), cx);
         language_selector::init(cx);
+        line_ending_selector::init(cx);
         toolchain_selector::init(cx);
         theme_selector::init(cx);
         settings_profile_selector::init(cx);
@@ -1419,30 +1419,35 @@ fn watch_themes(fs: Arc<dyn fs::Fs>, cx: &mut App) {
 fn watch_languages(fs: Arc<dyn fs::Fs>, languages: Arc<LanguageRegistry>, cx: &mut App) {
     use std::time::Duration;
 
-    let path = {
-        let p = Path::new("crates/languages/src");
-        let Ok(full_path) = p.canonicalize() else {
+    cx.background_spawn(async move {
+        let languages_src = Path::new("crates/languages/src");
+        let Some(languages_src) = fs.canonicalize(languages_src).await.log_err() else {
             return;
         };
-        full_path
-    };
 
-    cx.spawn(async move |_| {
-        let (mut events, _) = fs.watch(path.as_path(), Duration::from_millis(100)).await;
+        let (mut events, watcher) = fs.watch(&languages_src, Duration::from_millis(100)).await;
+
+        // add subdirectories since fs.watch is not recursive on Linux
+        if let Some(mut paths) = fs.read_dir(&languages_src).await.log_err() {
+            while let Some(path) = paths.next().await {
+                if let Some(path) = path.log_err()
+                    && fs.is_dir(&path).await
+                {
+                    watcher.add(&path).log_err();
+                }
+            }
+        }
+
         while let Some(event) = events.next().await {
-            let has_language_file = event.iter().any(|event| {
-                event
-                    .path
-                    .extension()
-                    .map(|ext| ext.to_string_lossy().as_ref() == "scm")
-                    .unwrap_or(false)
-            });
+            let has_language_file = event
+                .iter()
+                .any(|event| event.path.extension().is_some_and(|ext| ext == "scm"));
             if has_language_file {
                 languages.reload();
             }
         }
     })
-    .detach()
+    .detach();
 }
 
 #[cfg(not(debug_assertions))]
diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs
index 96f0f261dcce9268976f92ec028f0581fb648913..e14cbb10e85883231c1fd165d7c4f9d9beca155b 100644
--- a/crates/zed/src/zed.rs
+++ b/crates/zed/src/zed.rs
@@ -32,6 +32,7 @@ use gpui::{
 };
 use image_viewer::ImageInfo;
 use language::Capability;
+use language_onboarding::BasedPyrightBanner;
 use language_tools::lsp_button::{self, LspButton};
 use language_tools::lsp_log_view::LspLogToolbarItemView;
 use migrate::{MigrationBanner, MigrationEvent, MigrationNotification, MigrationType};
@@ -552,8 +553,6 @@ fn initialize_panels(
         let git_panel = GitPanel::load(workspace_handle.clone(), cx.clone());
         let channels_panel =
             collab_ui::collab_panel::CollabPanel::load(workspace_handle.clone(), cx.clone());
-        let chat_panel =
-            collab_ui::chat_panel::ChatPanel::load(workspace_handle.clone(), cx.clone());
         let notification_panel = collab_ui::notification_panel::NotificationPanel::load(
             workspace_handle.clone(),
             cx.clone(),
@@ -566,7 +565,6 @@ fn initialize_panels(
             terminal_panel,
             git_panel,
             channels_panel,
-            chat_panel,
             notification_panel,
             debug_panel,
         ) = futures::try_join!(
@@ -575,7 +573,6 @@ fn initialize_panels(
             git_panel,
             terminal_panel,
             channels_panel,
-            chat_panel,
             notification_panel,
             debug_panel,
         )?;
@@ -586,7 +583,6 @@ fn initialize_panels(
             workspace.add_panel(terminal_panel, window, cx);
             workspace.add_panel(git_panel, window, cx);
             workspace.add_panel(channels_panel, window, cx);
-            workspace.add_panel(chat_panel, window, cx);
             workspace.add_panel(notification_panel, window, cx);
             workspace.add_panel(debug_panel, window, cx);
         })?;
@@ -864,14 +860,6 @@ fn register_actions(
                 workspace.toggle_panel_focus::<collab_ui::collab_panel::CollabPanel>(window, cx);
             },
         )
-        .register_action(
-            |workspace: &mut Workspace,
-             _: &collab_ui::chat_panel::ToggleFocus,
-             window: &mut Window,
-             cx: &mut Context<Workspace>| {
-                workspace.toggle_panel_focus::<collab_ui::chat_panel::ChatPanel>(window, cx);
-            },
-        )
         .register_action(
             |workspace: &mut Workspace,
              _: &collab_ui::notification_panel::ToggleFocus,
@@ -1001,6 +989,8 @@ fn initialize_pane(
             toolbar.add_item(project_diff_toolbar, window, cx);
             let agent_diff_toolbar = cx.new(AgentDiffToolbar::new);
             toolbar.add_item(agent_diff_toolbar, window, cx);
+            let basedpyright_banner = cx.new(|cx| BasedPyrightBanner::new(workspace, cx));
+            toolbar.add_item(basedpyright_banner, window, cx);
         })
     });
 }
@@ -1167,7 +1157,7 @@ fn open_log_file(workspace: &mut Workspace, window: &mut Window, cx: &mut Contex
                         };
                         let project = workspace.project().clone();
                         let buffer = project.update(cx, |project, cx| {
-                            project.create_local_buffer(&log, None, cx)
+                            project.create_local_buffer(&log, None, false, cx)
                         });
 
                         let buffer = cx
@@ -1317,15 +1307,31 @@ pub fn handle_keymap_file_changes(
     })
     .detach();
 
-    let mut current_layout_id = cx.keyboard_layout().id().to_string();
-    cx.on_keyboard_layout_change(move |cx| {
-        let next_layout_id = cx.keyboard_layout().id();
-        if next_layout_id != current_layout_id {
-            current_layout_id = next_layout_id.to_string();
-            keyboard_layout_tx.unbounded_send(()).ok();
-        }
-    })
-    .detach();
+    #[cfg(target_os = "windows")]
+    {
+        let mut current_layout_id = cx.keyboard_layout().id().to_string();
+        cx.on_keyboard_layout_change(move |cx| {
+            let next_layout_id = cx.keyboard_layout().id();
+            if next_layout_id != current_layout_id {
+                current_layout_id = next_layout_id.to_string();
+                keyboard_layout_tx.unbounded_send(()).ok();
+            }
+        })
+        .detach();
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        let mut current_mapping = cx.keyboard_mapper().get_key_equivalents().cloned();
+        cx.on_keyboard_layout_change(move |cx| {
+            let next_mapping = cx.keyboard_mapper().get_key_equivalents();
+            if current_mapping.as_ref() != next_mapping {
+                current_mapping = next_mapping.cloned();
+                keyboard_layout_tx.unbounded_send(()).ok();
+            }
+        })
+        .detach();
+    }
 
     load_default_keymap(cx);
 
@@ -1733,7 +1739,7 @@ fn open_telemetry_log_file(
 
             workspace.update_in( cx, |workspace, window, cx| {
                 let project = workspace.project().clone();
-                let buffer = project.update(cx, |project, cx| project.create_local_buffer(&content, json, cx));
+                let buffer = project.update(cx, |project, cx| project.create_local_buffer(&content, json,false, cx));
                 let buffer = cx.new(|cx| {
                     MultiBuffer::singleton(buffer, cx).with_title("Telemetry Log".into())
                 });
@@ -1772,7 +1778,8 @@ fn open_bundled_file(
                 workspace.with_local_workspace(window, cx, |workspace, window, cx| {
                     let project = workspace.project();
                     let buffer = project.update(cx, move |project, cx| {
-                        let buffer = project.create_local_buffer(text.as_ref(), language, cx);
+                        let buffer =
+                            project.create_local_buffer(text.as_ref(), language, false, cx);
                         buffer.update(cx, |buffer, cx| {
                             buffer.set_capability(Capability::ReadOnly, cx);
                         });
@@ -4365,6 +4372,8 @@ mod tests {
                     | "vim::PushJump"
                     | "vim::PushDigraph"
                     | "vim::PushLiteral"
+                    | "vim::PushHelixNext"
+                    | "vim::PushHelixPrevious"
                     | "vim::Number"
                     | "vim::SelectRegister"
                     | "git::StageAndNext"
@@ -4453,7 +4462,6 @@ mod tests {
                 "branches",
                 "buffer_search",
                 "channel_modal",
-                "chat_panel",
                 "cli",
                 "client",
                 "collab",
@@ -4480,6 +4488,7 @@ mod tests {
                 "keymap_editor",
                 "keystroke_input",
                 "language_selector",
+                "line_ending",
                 "lsp_tool",
                 "markdown",
                 "menu",
@@ -4502,6 +4511,7 @@ mod tests {
                 "snippets",
                 "supermaven",
                 "svg",
+                "syntax_tree_view",
                 "tab_switcher",
                 "task",
                 "terminal",
@@ -4511,11 +4521,11 @@ mod tests {
                 "toolchain",
                 "variable_list",
                 "vim",
+                "window",
                 "workspace",
                 "zed",
                 "zed_predict_onboarding",
                 "zeta",
-                "window",
             ];
             assert_eq!(
                 all_namespaces,
diff --git a/crates/zed/src/zed/app_menus.rs b/crates/zed/src/zed/app_menus.rs
index 342fd26cb77aa08dcbc346609b3185f3263f0f1d..50b88dd4ed6b2d6287109451c894ccb2de4a977c 100644
--- a/crates/zed/src/zed/app_menus.rs
+++ b/crates/zed/src/zed/app_menus.rs
@@ -1,6 +1,7 @@
 use collab_ui::collab_panel;
 use gpui::{Menu, MenuItem, OsAction};
 use terminal_view::terminal_panel;
+use zed_actions::ToggleFocus as ToggleDebugPanel;
 
 pub fn app_menus() -> Vec<Menu> {
     use zed_actions::Quit;
@@ -126,6 +127,11 @@ pub fn app_menus() -> Vec<Menu> {
                 ),
                 MenuItem::action("Expand Selection", editor::actions::SelectLargerSyntaxNode),
                 MenuItem::action("Shrink Selection", editor::actions::SelectSmallerSyntaxNode),
+                MenuItem::action("Select Next Sibling", editor::actions::SelectNextSyntaxNode),
+                MenuItem::action(
+                    "Select Previous Sibling",
+                    editor::actions::SelectPreviousSyntaxNode,
+                ),
                 MenuItem::separator(),
                 MenuItem::action("Add Cursor Above", editor::actions::AddSelectionAbove),
                 MenuItem::action("Add Cursor Below", editor::actions::AddSelectionBelow),
@@ -175,6 +181,7 @@ pub fn app_menus() -> Vec<Menu> {
                 MenuItem::action("Outline Panel", outline_panel::ToggleFocus),
                 MenuItem::action("Collab Panel", collab_panel::ToggleFocus),
                 MenuItem::action("Terminal Panel", terminal_panel::ToggleFocus),
+                MenuItem::action("Debugger Panel", ToggleDebugPanel),
                 MenuItem::separator(),
                 MenuItem::action("Diagnostics", diagnostics::Deploy),
                 MenuItem::separator(),
diff --git a/crates/zed/src/zed/edit_prediction_registry.rs b/crates/zed/src/zed/edit_prediction_registry.rs
index 7b8b98018e6d6c608574ab81e912e8a98e363046..ae26427fc6547079b163235f5d1c3df26a489795 100644
--- a/crates/zed/src/zed/edit_prediction_registry.rs
+++ b/crates/zed/src/zed/edit_prediction_registry.rs
@@ -8,7 +8,7 @@ use settings::SettingsStore;
 use std::{cell::RefCell, rc::Rc, sync::Arc};
 use supermaven::{Supermaven, SupermavenCompletionProvider};
 use ui::Window;
-use zeta::{ProviderDataCollection, ZetaEditPredictionProvider};
+use zeta::ZetaEditPredictionProvider;
 
 pub fn init(client: Arc<Client>, user_store: Entity<UserStore>, cx: &mut App) {
     let editors: Rc<RefCell<HashMap<WeakEntity<Editor>, AnyWindowHandle>>> = Rc::default();
@@ -207,17 +207,15 @@ fn assign_edit_prediction_provider(
 
                 if let Some(buffer) = &singleton_buffer
                     && buffer.read(cx).file().is_some()
+                    && let Some(project) = editor.project()
                 {
                     zeta.update(cx, |zeta, cx| {
-                        zeta.register_buffer(buffer, cx);
+                        zeta.register_buffer(buffer, project, cx);
                     });
                 }
 
-                let data_collection =
-                    ProviderDataCollection::new(zeta.clone(), singleton_buffer, cx);
-
                 let provider =
-                    cx.new(|_| zeta::ZetaEditPredictionProvider::new(zeta, data_collection));
+                    cx.new(|_| zeta::ZetaEditPredictionProvider::new(zeta, singleton_buffer));
 
                 editor.set_edit_prediction_provider(Some(provider), window, cx);
             }
diff --git a/crates/zeta/Cargo.toml b/crates/zeta/Cargo.toml
index a9c2a7619f4db22e51c014672aa2100b30a2539a..09bcfa7f542ce9c01802c9cebc11dfc9a8da2542 100644
--- a/crates/zeta/Cargo.toml
+++ b/crates/zeta/Cargo.toml
@@ -72,6 +72,7 @@ gpui = { workspace = true, features = ["test-support"] }
 http_client = { workspace = true, features = ["test-support"] }
 indoc.workspace = true
 language = { workspace = true, features = ["test-support"] }
+parking_lot.workspace = true
 reqwest_client = { workspace = true, features = ["test-support"] }
 rpc = { workspace = true, features = ["test-support"] }
 settings = { workspace = true, features = ["test-support"] }
diff --git a/crates/zeta/src/init.rs b/crates/zeta/src/init.rs
index 6e5b31f99a76cb0e066348150e962396cf1ad9c6..f27667de6332bf4c3b8d2d705f281c9e3ba96a83 100644
--- a/crates/zeta/src/init.rs
+++ b/crates/zeta/src/init.rs
@@ -86,7 +86,7 @@ fn feature_gate_predict_edits_actions(cx: &mut App) {
             if is_ai_disabled {
                 filter.hide_action_types(&zeta_all_action_types);
             } else if has_feature_flag {
-                filter.show_action_types(rate_completion_action_types.iter());
+                filter.show_action_types(&rate_completion_action_types);
             } else {
                 filter.hide_action_types(&rate_completion_action_types);
             }
@@ -98,7 +98,7 @@ fn feature_gate_predict_edits_actions(cx: &mut App) {
         if !DisableAiSettings::get_global(cx).disable_ai {
             if is_enabled {
                 CommandPaletteFilter::update_global(cx, |filter, _cx| {
-                    filter.show_action_types(rate_completion_action_types.iter());
+                    filter.show_action_types(&rate_completion_action_types);
                 });
             } else {
                 CommandPaletteFilter::update_global(cx, |filter, _cx| {
diff --git a/crates/zeta/src/input_excerpt.rs b/crates/zeta/src/input_excerpt.rs
index f4add6593e9a2b15679b5b0e6e660b4ce6a52f87..06bff5b1bea0f099b2ccd98605ac5de5bb5e6360 100644
--- a/crates/zeta/src/input_excerpt.rs
+++ b/crates/zeta/src/input_excerpt.rs
@@ -1,6 +1,6 @@
 use crate::{
     CURSOR_MARKER, EDITABLE_REGION_END_MARKER, EDITABLE_REGION_START_MARKER, START_OF_FILE_MARKER,
-    tokens_for_bytes,
+    guess_token_count,
 };
 use language::{BufferSnapshot, Point};
 use std::{fmt::Write, ops::Range};
@@ -22,7 +22,7 @@ pub fn excerpt_for_cursor_position(
     let mut remaining_edit_tokens = editable_region_token_limit;
 
     while let Some(parent) = snapshot.syntax_ancestor(scope_range.clone()) {
-        let parent_tokens = tokens_for_bytes(parent.byte_range().len());
+        let parent_tokens = guess_token_count(parent.byte_range().len());
         let parent_point_range = Point::new(
             parent.start_position().row as u32,
             parent.start_position().column as u32,
@@ -99,7 +99,7 @@ fn expand_range(
         if remaining_tokens > 0 && expanded_range.start.row > 0 {
             expanded_range.start.row -= 1;
             let line_tokens =
-                tokens_for_bytes(snapshot.line_len(expanded_range.start.row) as usize);
+                guess_token_count(snapshot.line_len(expanded_range.start.row) as usize);
             remaining_tokens = remaining_tokens.saturating_sub(line_tokens);
             expanded = true;
         }
@@ -107,7 +107,7 @@ fn expand_range(
         if remaining_tokens > 0 && expanded_range.end.row < snapshot.max_point().row {
             expanded_range.end.row += 1;
             expanded_range.end.column = snapshot.line_len(expanded_range.end.row);
-            let line_tokens = tokens_for_bytes(expanded_range.end.column as usize);
+            let line_tokens = guess_token_count(expanded_range.end.column as usize);
             remaining_tokens = remaining_tokens.saturating_sub(line_tokens);
             expanded = true;
         }
@@ -149,7 +149,7 @@ mod tests {
                 let mut rng = rand::thread_rng();
                 let mut numbers = Vec::new();
                 for _ in 0..5 {
-                    numbers.push(rng.gen_range(1..101));
+                    numbers.push(rng.random_range(1..101));
                 }
                 numbers
             }
@@ -208,7 +208,7 @@ mod tests {
             <|editable_region_end|>
                 let mut numbers = Vec::new();
                 for _ in 0..5 {
-                    numbers.push(rng.gen_range(1..101));
+                    numbers.push(rng.random_range(1..101));
             ```"#}
         );
     }
diff --git a/crates/zeta/src/license_detection.rs b/crates/zeta/src/license_detection.rs
index 5f207a44e8bd2028e6a2b416e978f101cfe5bd57..e06e1577a66cc160efa00213b80c6ca407f7be85 100644
--- a/crates/zeta/src/license_detection.rs
+++ b/crates/zeta/src/license_detection.rs
@@ -358,7 +358,6 @@ impl LicenseDetectionWatcher {
 
 #[cfg(test)]
 mod tests {
-
     use fs::FakeFs;
     use gpui::TestAppContext;
     use serde_json::json;
diff --git a/crates/zeta/src/zeta.rs b/crates/zeta/src/zeta.rs
index e0cfd23dd26cd7ea49181b5aabc16f00f4fd826a..dfcf98f025c2e020d6545efca64d4ab12579e370 100644
--- a/crates/zeta/src/zeta.rs
+++ b/crates/zeta/src/zeta.rs
@@ -29,18 +29,19 @@ use gpui::{
 use http_client::{AsyncBody, HttpClient, Method, Request, Response};
 use input_excerpt::excerpt_for_cursor_position;
 use language::{
-    Anchor, Buffer, BufferSnapshot, EditPreview, OffsetRangeExt, ToOffset, ToPoint, text_diff,
+    Anchor, Buffer, BufferSnapshot, EditPreview, File, OffsetRangeExt, ToOffset, ToPoint, text_diff,
 };
 use language_model::{LlmApiToken, RefreshLlmTokenListener};
 use project::{Project, ProjectPath};
 use release_channel::AppVersion;
 use settings::WorktreeId;
+use std::collections::hash_map;
+use std::mem;
 use std::str::FromStr;
 use std::{
     cmp,
     fmt::Write,
     future::Future,
-    mem,
     ops::Range,
     path::Path,
     rc::Rc,
@@ -64,7 +65,6 @@ const ZED_PREDICT_DATA_COLLECTION_CHOICE: &str = "zed_predict_data_collection_ch
 const MAX_CONTEXT_TOKENS: usize = 150;
 const MAX_REWRITE_TOKENS: usize = 350;
 const MAX_EVENT_TOKENS: usize = 500;
-const MAX_DIAGNOSTIC_GROUPS: usize = 10;
 
 /// Maximum number of events to track.
 const MAX_EVENT_COUNT: usize = 16;
@@ -211,12 +211,11 @@ impl std::fmt::Debug for EditPrediction {
 }
 
 pub struct Zeta {
+    projects: HashMap<EntityId, ZetaProject>,
     client: Arc<Client>,
-    events: VecDeque<Event>,
-    registered_buffers: HashMap<gpui::EntityId, RegisteredBuffer>,
     shown_completions: VecDeque<EditPrediction>,
     rated_completions: HashSet<EditPredictionId>,
-    data_collection_choice: Entity<DataCollectionChoice>,
+    data_collection_choice: DataCollectionChoice,
     llm_token: LlmApiToken,
     _llm_token_subscription: Subscription,
     /// Whether an update to a newer version of Zed is required to continue using Zeta.
@@ -225,6 +224,11 @@ pub struct Zeta {
     license_detection_watchers: HashMap<WorktreeId, Rc<LicenseDetectionWatcher>>,
 }
 
+struct ZetaProject {
+    events: VecDeque<Event>,
+    registered_buffers: HashMap<gpui::EntityId, RegisteredBuffer>,
+}
+
 impl Zeta {
     pub fn global(cx: &mut App) -> Option<Entity<Self>> {
         cx.try_global::<ZetaGlobal>().map(|global| global.0.clone())
@@ -255,7 +259,9 @@ impl Zeta {
     }
 
     pub fn clear_history(&mut self) {
-        self.events.clear();
+        for zeta_project in self.projects.values_mut() {
+            zeta_project.events.clear();
+        }
     }
 
     pub fn usage(&self, cx: &App) -> Option<EditPredictionUsage> {
@@ -264,16 +270,12 @@ impl Zeta {
 
     fn new(client: Arc<Client>, user_store: Entity<UserStore>, cx: &mut Context<Self>) -> Self {
         let refresh_llm_token_listener = RefreshLlmTokenListener::global(cx);
-
-        let data_collection_choice = Self::load_data_collection_choices();
-        let data_collection_choice = cx.new(|_| data_collection_choice);
-
+        let data_collection_choice = Self::load_data_collection_choice();
         Self {
+            projects: HashMap::default(),
             client,
-            events: VecDeque::new(),
             shown_completions: VecDeque::new(),
             rated_completions: HashSet::default(),
-            registered_buffers: HashMap::default(),
             data_collection_choice,
             llm_token: LlmApiToken::default(),
             _llm_token_subscription: cx.subscribe(
@@ -294,12 +296,35 @@ impl Zeta {
         }
     }
 
-    fn push_event(&mut self, event: Event) {
+    fn get_or_init_zeta_project(
+        &mut self,
+        project: &Entity<Project>,
+        cx: &mut Context<Self>,
+    ) -> &mut ZetaProject {
+        let project_id = project.entity_id();
+        match self.projects.entry(project_id) {
+            hash_map::Entry::Occupied(entry) => entry.into_mut(),
+            hash_map::Entry::Vacant(entry) => {
+                cx.observe_release(project, move |this, _, _cx| {
+                    this.projects.remove(&project_id);
+                })
+                .detach();
+                entry.insert(ZetaProject {
+                    events: VecDeque::with_capacity(MAX_EVENT_COUNT),
+                    registered_buffers: HashMap::default(),
+                })
+            }
+        }
+    }
+
+    fn push_event(zeta_project: &mut ZetaProject, event: Event) {
+        let events = &mut zeta_project.events;
+
         if let Some(Event::BufferChange {
             new_snapshot: last_new_snapshot,
             timestamp: last_timestamp,
             ..
-        }) = self.events.back_mut()
+        }) = events.back_mut()
         {
             // Coalesce edits for the same buffer when they happen one after the other.
             let Event::BufferChange {
@@ -318,53 +343,67 @@ impl Zeta {
             }
         }
 
-        self.events.push_back(event);
-        if self.events.len() >= MAX_EVENT_COUNT {
+        if events.len() >= MAX_EVENT_COUNT {
             // These are halved instead of popping to improve prompt caching.
-            self.events.drain(..MAX_EVENT_COUNT / 2);
+            events.drain(..MAX_EVENT_COUNT / 2);
         }
-    }
 
-    pub fn register_buffer(&mut self, buffer: &Entity<Buffer>, cx: &mut Context<Self>) {
-        let buffer_id = buffer.entity_id();
-        let weak_buffer = buffer.downgrade();
-
-        if let std::collections::hash_map::Entry::Vacant(entry) =
-            self.registered_buffers.entry(buffer_id)
-        {
-            let snapshot = buffer.read(cx).snapshot();
-
-            entry.insert(RegisteredBuffer {
-                snapshot,
-                _subscriptions: [
-                    cx.subscribe(buffer, move |this, buffer, event, cx| {
-                        this.handle_buffer_event(buffer, event, cx);
-                    }),
-                    cx.observe_release(buffer, move |this, _buffer, _cx| {
-                        this.registered_buffers.remove(&weak_buffer.entity_id());
-                    }),
-                ],
-            });
-        };
+        events.push_back(event);
     }
 
-    fn handle_buffer_event(
+    pub fn register_buffer(
         &mut self,
-        buffer: Entity<Buffer>,
-        event: &language::BufferEvent,
+        buffer: &Entity<Buffer>,
+        project: &Entity<Project>,
         cx: &mut Context<Self>,
     ) {
-        if let language::BufferEvent::Edited = event {
-            self.report_changes_for_buffer(&buffer, cx);
+        let zeta_project = self.get_or_init_zeta_project(project, cx);
+        Self::register_buffer_impl(zeta_project, buffer, project, cx);
+    }
+
+    fn register_buffer_impl<'a>(
+        zeta_project: &'a mut ZetaProject,
+        buffer: &Entity<Buffer>,
+        project: &Entity<Project>,
+        cx: &mut Context<Self>,
+    ) -> &'a mut RegisteredBuffer {
+        let buffer_id = buffer.entity_id();
+        match zeta_project.registered_buffers.entry(buffer_id) {
+            hash_map::Entry::Occupied(entry) => entry.into_mut(),
+            hash_map::Entry::Vacant(entry) => {
+                let snapshot = buffer.read(cx).snapshot();
+                let project_entity_id = project.entity_id();
+                entry.insert(RegisteredBuffer {
+                    snapshot,
+                    _subscriptions: [
+                        cx.subscribe(buffer, {
+                            let project = project.downgrade();
+                            move |this, buffer, event, cx| {
+                                if let language::BufferEvent::Edited = event
+                                    && let Some(project) = project.upgrade()
+                                {
+                                    this.report_changes_for_buffer(&buffer, &project, cx);
+                                }
+                            }
+                        }),
+                        cx.observe_release(buffer, move |this, _buffer, _cx| {
+                            let Some(zeta_project) = this.projects.get_mut(&project_entity_id)
+                            else {
+                                return;
+                            };
+                            zeta_project.registered_buffers.remove(&buffer_id);
+                        }),
+                    ],
+                })
+            }
         }
     }
 
     fn request_completion_impl<F, R>(
         &mut self,
-        project: Option<&Entity<Project>>,
+        project: &Entity<Project>,
         buffer: &Entity<Buffer>,
         cursor: language::Anchor,
-        can_collect_data: bool,
         cx: &mut Context<Self>,
         perform_predict_edits: F,
     ) -> Task<Result<Option<EditPrediction>>>
@@ -376,19 +415,27 @@ impl Zeta {
     {
         let buffer = buffer.clone();
         let buffer_snapshotted_at = Instant::now();
-        let snapshot = self.report_changes_for_buffer(&buffer, cx);
+        let snapshot = self.report_changes_for_buffer(&buffer, project, cx);
         let zeta = cx.entity();
-        let events = self.events.clone();
         let client = self.client.clone();
         let llm_token = self.llm_token.clone();
         let app_version = AppVersion::global(cx);
 
-        let git_info = if let (true, Some(project), Some(file)) =
-            (can_collect_data, project, snapshot.file())
-        {
-            git_info_for_file(project, &ProjectPath::from_file(file.as_ref(), cx), cx)
+        let zeta_project = self.get_or_init_zeta_project(project, cx);
+        let mut events = Vec::with_capacity(zeta_project.events.len());
+        events.extend(zeta_project.events.iter().cloned());
+        let events = Arc::new(events);
+
+        let (git_info, can_collect_file) = if let Some(file) = snapshot.file() {
+            let can_collect_file = self.can_collect_file(file, cx);
+            let git_info = if can_collect_file {
+                git_info_for_file(project, &ProjectPath::from_file(file.as_ref(), cx), cx)
+            } else {
+                None
+            };
+            (git_info, can_collect_file)
         } else {
-            None
+            (None, false)
         };
 
         let full_path: Arc<Path> = snapshot
@@ -398,25 +445,35 @@ impl Zeta {
         let full_path_str = full_path.to_string_lossy().to_string();
         let cursor_point = cursor.to_point(&snapshot);
         let cursor_offset = cursor_point.to_offset(&snapshot);
-        let make_events_prompt = move || prompt_for_events(&events, MAX_EVENT_TOKENS);
+        let prompt_for_events = {
+            let events = events.clone();
+            move || prompt_for_events_impl(&events, MAX_EVENT_TOKENS)
+        };
         let gather_task = gather_context(
-            project,
             full_path_str,
             &snapshot,
             cursor_point,
-            make_events_prompt,
-            can_collect_data,
-            git_info,
+            prompt_for_events,
             cx,
         );
 
         cx.spawn(async move |this, cx| {
             let GatherContextOutput {
-                body,
+                mut body,
                 editable_range,
+                included_events_count,
             } = gather_task.await?;
             let done_gathering_context_at = Instant::now();
 
+            let included_events = &events[events.len() - included_events_count..events.len()];
+            body.can_collect_data = can_collect_file
+                && this
+                    .read_with(cx, |this, cx| this.can_collect_events(included_events, cx))
+                    .unwrap_or(false);
+            if body.can_collect_data {
+                body.git_info = git_info;
+            }
+
             log::debug!(
                 "Events:\n{}\nExcerpt:\n{:?}",
                 body.input_events,
@@ -512,191 +569,28 @@ impl Zeta {
         })
     }
 
-    // Generates several example completions of various states to fill the Zeta completion modal
-    #[cfg(any(test, feature = "test-support"))]
-    pub fn fill_with_fake_completions(&mut self, cx: &mut Context<Self>) -> Task<()> {
-        use language::Point;
-
-        let test_buffer_text = indoc::indoc! {r#"a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
-            And maybe a short line
-
-            Then a few lines
-
-            and then another
-            "#};
-
-        let project = None;
-        let buffer = cx.new(|cx| Buffer::local(test_buffer_text, cx));
-        let position = buffer.read(cx).anchor_before(Point::new(1, 0));
-
-        let completion_tasks = vec![
-            self.fake_completion(
-                project,
-                &buffer,
-                position,
-                PredictEditsResponse {
-                    request_id: Uuid::parse_str("e7861db5-0cea-4761-b1c5-ad083ac53a80").unwrap(),
-                    output_excerpt: format!("{EDITABLE_REGION_START_MARKER}
-a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
-[here's an edit]
-And maybe a short line
-Then a few lines
-and then another
-{EDITABLE_REGION_END_MARKER}
-                        ", ),
-                },
-                cx,
-            ),
-            self.fake_completion(
-                project,
-                &buffer,
-                position,
-                PredictEditsResponse {
-                    request_id: Uuid::parse_str("077c556a-2c49-44e2-bbc6-dafc09032a5e").unwrap(),
-                    output_excerpt: format!(r#"{EDITABLE_REGION_START_MARKER}
-a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
-And maybe a short line
-[and another edit]
-Then a few lines
-and then another
-{EDITABLE_REGION_END_MARKER}
-                        "#),
-                },
-                cx,
-            ),
-            self.fake_completion(
-                project,
-                &buffer,
-                position,
-                PredictEditsResponse {
-                    request_id: Uuid::parse_str("df8c7b23-3d1d-4f99-a306-1f6264a41277").unwrap(),
-                    output_excerpt: format!(r#"{EDITABLE_REGION_START_MARKER}
-a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
-And maybe a short line
-
-Then a few lines
-
-and then another
-{EDITABLE_REGION_END_MARKER}
-                        "#),
-                },
-                cx,
-            ),
-            self.fake_completion(
-                project,
-                &buffer,
-                position,
-                PredictEditsResponse {
-                    request_id: Uuid::parse_str("c743958d-e4d8-44a8-aa5b-eb1e305c5f5c").unwrap(),
-                    output_excerpt: format!(r#"{EDITABLE_REGION_START_MARKER}
-a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
-And maybe a short line
-
-Then a few lines
-
-and then another
-{EDITABLE_REGION_END_MARKER}
-                        "#),
-                },
-                cx,
-            ),
-            self.fake_completion(
-                project,
-                &buffer,
-                position,
-                PredictEditsResponse {
-                    request_id: Uuid::parse_str("ff5cd7ab-ad06-4808-986e-d3391e7b8355").unwrap(),
-                    output_excerpt: format!(r#"{EDITABLE_REGION_START_MARKER}
-a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
-And maybe a short line
-Then a few lines
-[a third completion]
-and then another
-{EDITABLE_REGION_END_MARKER}
-                        "#),
-                },
-                cx,
-            ),
-            self.fake_completion(
-                project,
-                &buffer,
-                position,
-                PredictEditsResponse {
-                    request_id: Uuid::parse_str("83cafa55-cdba-4b27-8474-1865ea06be94").unwrap(),
-                    output_excerpt: format!(r#"{EDITABLE_REGION_START_MARKER}
-a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
-And maybe a short line
-and then another
-[fourth completion example]
-{EDITABLE_REGION_END_MARKER}
-                        "#),
-                },
-                cx,
-            ),
-            self.fake_completion(
-                project,
-                &buffer,
-                position,
-                PredictEditsResponse {
-                    request_id: Uuid::parse_str("d5bd3afd-8723-47c7-bd77-15a3a926867b").unwrap(),
-                    output_excerpt: format!(r#"{EDITABLE_REGION_START_MARKER}
-a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
-And maybe a short line
-Then a few lines
-and then another
-[fifth and final completion]
-{EDITABLE_REGION_END_MARKER}
-                        "#),
-                },
-                cx,
-            ),
-        ];
-
-        cx.spawn(async move |zeta, cx| {
-            for task in completion_tasks {
-                task.await.unwrap();
-            }
-
-            zeta.update(cx, |zeta, _cx| {
-                zeta.shown_completions.get_mut(2).unwrap().edits = Arc::new([]);
-                zeta.shown_completions.get_mut(3).unwrap().edits = Arc::new([]);
-            })
-            .ok();
-        })
-    }
-
     #[cfg(any(test, feature = "test-support"))]
     pub fn fake_completion(
         &mut self,
-        project: Option<&Entity<Project>>,
+        project: &Entity<Project>,
         buffer: &Entity<Buffer>,
         position: language::Anchor,
         response: PredictEditsResponse,
         cx: &mut Context<Self>,
     ) -> Task<Result<Option<EditPrediction>>> {
-        use std::future::ready;
-
-        self.request_completion_impl(project, buffer, position, false, cx, |_params| {
-            ready(Ok((response, None)))
+        self.request_completion_impl(project, buffer, position, cx, |_params| {
+            std::future::ready(Ok((response, None)))
         })
     }
 
     pub fn request_completion(
         &mut self,
-        project: Option<&Entity<Project>>,
+        project: &Entity<Project>,
         buffer: &Entity<Buffer>,
         position: language::Anchor,
-        can_collect_data: bool,
         cx: &mut Context<Self>,
     ) -> Task<Result<Option<EditPrediction>>> {
-        self.request_completion_impl(
-            project,
-            buffer,
-            position,
-            can_collect_data,
-            cx,
-            Self::perform_predict_edits,
-        )
+        self.request_completion_impl(project, buffer, position, cx, Self::perform_predict_edits)
     }
 
     pub fn perform_predict_edits(
@@ -1043,29 +937,80 @@ and then another
     fn report_changes_for_buffer(
         &mut self,
         buffer: &Entity<Buffer>,
+        project: &Entity<Project>,
         cx: &mut Context<Self>,
     ) -> BufferSnapshot {
-        self.register_buffer(buffer, cx);
+        let zeta_project = self.get_or_init_zeta_project(project, cx);
+        let registered_buffer = Self::register_buffer_impl(zeta_project, buffer, project, cx);
 
-        let registered_buffer = self
-            .registered_buffers
-            .get_mut(&buffer.entity_id())
-            .unwrap();
         let new_snapshot = buffer.read(cx).snapshot();
-
         if new_snapshot.version != registered_buffer.snapshot.version {
             let old_snapshot = mem::replace(&mut registered_buffer.snapshot, new_snapshot.clone());
-            self.push_event(Event::BufferChange {
-                old_snapshot,
-                new_snapshot: new_snapshot.clone(),
-                timestamp: Instant::now(),
-            });
+            Self::push_event(
+                zeta_project,
+                Event::BufferChange {
+                    old_snapshot,
+                    new_snapshot: new_snapshot.clone(),
+                    timestamp: Instant::now(),
+                },
+            );
         }
 
         new_snapshot
     }
 
-    fn load_data_collection_choices() -> DataCollectionChoice {
+    fn can_collect_file(&self, file: &Arc<dyn File>, cx: &App) -> bool {
+        self.data_collection_choice.is_enabled() && self.is_file_open_source(file, cx)
+    }
+
+    fn can_collect_events(&self, events: &[Event], cx: &App) -> bool {
+        if !self.data_collection_choice.is_enabled() {
+            return false;
+        }
+        let mut last_checked_file = None;
+        for event in events {
+            match event {
+                Event::BufferChange {
+                    old_snapshot,
+                    new_snapshot,
+                    ..
+                } => {
+                    if let Some(old_file) = old_snapshot.file()
+                        && let Some(new_file) = new_snapshot.file()
+                    {
+                        if let Some(last_checked_file) = last_checked_file
+                            && Arc::ptr_eq(last_checked_file, old_file)
+                            && Arc::ptr_eq(last_checked_file, new_file)
+                        {
+                            continue;
+                        }
+                        if !self.can_collect_file(old_file, cx) {
+                            return false;
+                        }
+                        if !Arc::ptr_eq(old_file, new_file) && !self.can_collect_file(new_file, cx)
+                        {
+                            return false;
+                        }
+                        last_checked_file = Some(new_file);
+                    } else {
+                        return false;
+                    }
+                }
+            }
+        }
+        true
+    }
+
+    fn is_file_open_source(&self, file: &Arc<dyn File>, cx: &App) -> bool {
+        if !file.is_local() || file.is_private() {
+            return false;
+        }
+        self.license_detection_watchers
+            .get(&file.worktree_id(cx))
+            .is_some_and(|watcher| watcher.is_project_open_source())
+    }
+
+    fn load_data_collection_choice() -> DataCollectionChoice {
         let choice = KEY_VALUE_STORE
             .read_kvp(ZED_PREDICT_DATA_COLLECTION_CHOICE)
             .log_err()
@@ -1081,6 +1026,17 @@ and then another
             None => DataCollectionChoice::NotAnswered,
         }
     }
+
+    fn toggle_data_collection_choice(&mut self, cx: &mut Context<Self>) {
+        self.data_collection_choice = self.data_collection_choice.toggle();
+        let new_choice = self.data_collection_choice;
+        db::write_and_log(cx, move || {
+            KEY_VALUE_STORE.write_kvp(
+                ZED_PREDICT_DATA_COLLECTION_CHOICE.into(),
+                new_choice.is_enabled().to_string(),
+            )
+        });
+    }
 }
 
 pub struct PerformPredictEditsParams {
@@ -1137,49 +1093,19 @@ fn git_info_for_file(
 pub struct GatherContextOutput {
     pub body: PredictEditsBody,
     pub editable_range: Range<usize>,
+    pub included_events_count: usize,
 }
 
 pub fn gather_context(
-    project: Option<&Entity<Project>>,
     full_path_str: String,
     snapshot: &BufferSnapshot,
     cursor_point: language::Point,
-    make_events_prompt: impl FnOnce() -> String + Send + 'static,
-    can_collect_data: bool,
-    git_info: Option<PredictEditsGitInfo>,
+    prompt_for_events: impl FnOnce() -> (String, usize) + Send + 'static,
     cx: &App,
 ) -> Task<Result<GatherContextOutput>> {
-    let local_lsp_store =
-        project.and_then(|project| project.read(cx).lsp_store().read(cx).as_local());
-    let diagnostic_groups: Vec<(String, serde_json::Value)> =
-        if can_collect_data && let Some(local_lsp_store) = local_lsp_store {
-            snapshot
-                .diagnostic_groups(None)
-                .into_iter()
-                .filter_map(|(language_server_id, diagnostic_group)| {
-                    let language_server =
-                        local_lsp_store.running_language_server_for_id(language_server_id)?;
-                    let diagnostic_group = diagnostic_group.resolve::<usize>(snapshot);
-                    let language_server_name = language_server.name().to_string();
-                    let serialized = serde_json::to_value(diagnostic_group).unwrap();
-                    Some((language_server_name, serialized))
-                })
-                .collect::<Vec<_>>()
-        } else {
-            Vec::new()
-        };
-
     cx.background_spawn({
         let snapshot = snapshot.clone();
         async move {
-            let diagnostic_groups = if diagnostic_groups.is_empty()
-                || diagnostic_groups.len() >= MAX_DIAGNOSTIC_GROUPS
-            {
-                None
-            } else {
-                Some(diagnostic_groups)
-            };
-
             let input_excerpt = excerpt_for_cursor_position(
                 cursor_point,
                 &full_path_str,
@@ -1187,15 +1113,15 @@ pub fn gather_context(
                 MAX_REWRITE_TOKENS,
                 MAX_CONTEXT_TOKENS,
             );
-            let input_events = make_events_prompt();
+            let (input_events, included_events_count) = prompt_for_events();
             let editable_range = input_excerpt.editable_range.to_offset(&snapshot);
 
             let body = PredictEditsBody {
                 input_events,
                 input_excerpt: input_excerpt.prompt,
-                can_collect_data,
-                diagnostic_groups,
-                git_info,
+                can_collect_data: false,
+                diagnostic_groups: None,
+                git_info: None,
                 outline: None,
                 speculated_output: None,
             };
@@ -1203,18 +1129,19 @@ pub fn gather_context(
             Ok(GatherContextOutput {
                 body,
                 editable_range,
+                included_events_count,
             })
         }
     })
 }
 
-fn prompt_for_events(events: &VecDeque<Event>, mut remaining_tokens: usize) -> String {
+fn prompt_for_events_impl(events: &[Event], mut remaining_tokens: usize) -> (String, usize) {
     let mut result = String::new();
-    for event in events.iter().rev() {
+    for (ix, event) in events.iter().rev().enumerate() {
         let event_string = event.to_prompt();
-        let event_tokens = tokens_for_bytes(event_string.len());
+        let event_tokens = guess_token_count(event_string.len());
         if event_tokens > remaining_tokens {
-            break;
+            return (result, ix);
         }
 
         if !result.is_empty() {
@@ -1223,7 +1150,7 @@ fn prompt_for_events(events: &VecDeque<Event>, mut remaining_tokens: usize) -> S
         result.insert_str(0, &event_string);
         remaining_tokens -= event_tokens;
     }
-    result
+    return (result, events.len());
 }
 
 struct RegisteredBuffer {
@@ -1334,6 +1261,7 @@ impl DataCollectionChoice {
         }
     }
 
+    #[must_use]
     pub fn toggle(&self) -> DataCollectionChoice {
         match self {
             Self::Enabled => Self::Disabled,
@@ -1352,79 +1280,6 @@ impl From<bool> for DataCollectionChoice {
     }
 }
 
-pub struct ProviderDataCollection {
-    /// When set to None, data collection is not possible in the provider buffer
-    choice: Option<Entity<DataCollectionChoice>>,
-    license_detection_watcher: Option<Rc<LicenseDetectionWatcher>>,
-}
-
-impl ProviderDataCollection {
-    pub fn new(zeta: Entity<Zeta>, buffer: Option<Entity<Buffer>>, cx: &mut App) -> Self {
-        let choice_and_watcher = buffer.and_then(|buffer| {
-            let file = buffer.read(cx).file()?;
-
-            if !file.is_local() || file.is_private() {
-                return None;
-            }
-
-            let zeta = zeta.read(cx);
-            let choice = zeta.data_collection_choice.clone();
-
-            let license_detection_watcher = zeta
-                .license_detection_watchers
-                .get(&file.worktree_id(cx))
-                .cloned()?;
-
-            Some((choice, license_detection_watcher))
-        });
-
-        if let Some((choice, watcher)) = choice_and_watcher {
-            ProviderDataCollection {
-                choice: Some(choice),
-                license_detection_watcher: Some(watcher),
-            }
-        } else {
-            ProviderDataCollection {
-                choice: None,
-                license_detection_watcher: None,
-            }
-        }
-    }
-
-    pub fn can_collect_data(&self, cx: &App) -> bool {
-        self.is_data_collection_enabled(cx) && self.is_project_open_source()
-    }
-
-    pub fn is_data_collection_enabled(&self, cx: &App) -> bool {
-        self.choice
-            .as_ref()
-            .is_some_and(|choice| choice.read(cx).is_enabled())
-    }
-
-    fn is_project_open_source(&self) -> bool {
-        self.license_detection_watcher
-            .as_ref()
-            .is_some_and(|watcher| watcher.is_project_open_source())
-    }
-
-    pub fn toggle(&mut self, cx: &mut App) {
-        if let Some(choice) = self.choice.as_mut() {
-            let new_choice = choice.update(cx, |choice, _cx| {
-                let new_choice = choice.toggle();
-                *choice = new_choice;
-                new_choice
-            });
-
-            db::write_and_log(cx, move || {
-                KEY_VALUE_STORE.write_kvp(
-                    ZED_PREDICT_DATA_COLLECTION_CHOICE.into(),
-                    new_choice.is_enabled().to_string(),
-                )
-            });
-        }
-    }
-}
-
 async fn llm_token_retry(
     llm_token: &LlmApiToken,
     client: &Arc<Client>,
@@ -1455,24 +1310,23 @@ async fn llm_token_retry(
 
 pub struct ZetaEditPredictionProvider {
     zeta: Entity<Zeta>,
+    singleton_buffer: Option<Entity<Buffer>>,
     pending_completions: ArrayVec<PendingCompletion, 2>,
     next_pending_completion_id: usize,
     current_completion: Option<CurrentEditPrediction>,
-    /// None if this is entirely disabled for this provider
-    provider_data_collection: ProviderDataCollection,
     last_request_timestamp: Instant,
 }
 
 impl ZetaEditPredictionProvider {
     pub const THROTTLE_TIMEOUT: Duration = Duration::from_millis(300);
 
-    pub fn new(zeta: Entity<Zeta>, provider_data_collection: ProviderDataCollection) -> Self {
+    pub fn new(zeta: Entity<Zeta>, singleton_buffer: Option<Entity<Buffer>>) -> Self {
         Self {
             zeta,
+            singleton_buffer,
             pending_completions: ArrayVec::new(),
             next_pending_completion_id: 0,
             current_completion: None,
-            provider_data_collection,
             last_request_timestamp: Instant::now(),
         }
     }
@@ -1496,21 +1350,29 @@ impl edit_prediction::EditPredictionProvider for ZetaEditPredictionProvider {
     }
 
     fn data_collection_state(&self, cx: &App) -> DataCollectionState {
-        let is_project_open_source = self.provider_data_collection.is_project_open_source();
-
-        if self.provider_data_collection.is_data_collection_enabled(cx) {
-            DataCollectionState::Enabled {
-                is_project_open_source,
+        if let Some(buffer) = &self.singleton_buffer
+            && let Some(file) = buffer.read(cx).file()
+        {
+            let is_project_open_source = self.zeta.read(cx).is_file_open_source(file, cx);
+            if self.zeta.read(cx).data_collection_choice.is_enabled() {
+                DataCollectionState::Enabled {
+                    is_project_open_source,
+                }
+            } else {
+                DataCollectionState::Disabled {
+                    is_project_open_source,
+                }
             }
         } else {
-            DataCollectionState::Disabled {
-                is_project_open_source,
-            }
+            return DataCollectionState::Disabled {
+                is_project_open_source: false,
+            };
         }
     }
 
     fn toggle_data_collection(&mut self, cx: &mut App) {
-        self.provider_data_collection.toggle(cx);
+        self.zeta
+            .update(cx, |zeta, cx| zeta.toggle_data_collection_choice(cx));
     }
 
     fn usage(&self, cx: &App) -> Option<EditPredictionUsage> {
@@ -1540,6 +1402,9 @@ impl edit_prediction::EditPredictionProvider for ZetaEditPredictionProvider {
         if self.zeta.read(cx).update_required {
             return;
         }
+        let Some(project) = project else {
+            return;
+        };
 
         if self
             .zeta
@@ -1565,7 +1430,6 @@ impl edit_prediction::EditPredictionProvider for ZetaEditPredictionProvider {
 
         let pending_completion_id = self.next_pending_completion_id;
         self.next_pending_completion_id += 1;
-        let can_collect_data = self.provider_data_collection.can_collect_data(cx);
         let last_request_timestamp = self.last_request_timestamp;
 
         let task = cx.spawn(async move |this, cx| {
@@ -1578,13 +1442,7 @@ impl edit_prediction::EditPredictionProvider for ZetaEditPredictionProvider {
             let completion_request = this.update(cx, |this, cx| {
                 this.last_request_timestamp = Instant::now();
                 this.zeta.update(cx, |zeta, cx| {
-                    zeta.request_completion(
-                        project.as_ref(),
-                        &buffer,
-                        position,
-                        can_collect_data,
-                        cx,
-                    )
+                    zeta.request_completion(&project, &buffer, position, cx)
                 })
             });
 
@@ -1753,16 +1611,16 @@ impl edit_prediction::EditPredictionProvider for ZetaEditPredictionProvider {
     }
 }
 
-fn tokens_for_bytes(bytes: usize) -> usize {
-    /// Typical number of string bytes per token for the purposes of limiting model input. This is
-    /// intentionally low to err on the side of underestimating limits.
-    const BYTES_PER_TOKEN_GUESS: usize = 3;
+/// Typical number of string bytes per token for the purposes of limiting model input. This is
+/// intentionally low to err on the side of underestimating limits.
+const BYTES_PER_TOKEN_GUESS: usize = 3;
+
+fn guess_token_count(bytes: usize) -> usize {
     bytes / BYTES_PER_TOKEN_GUESS
 }
 
 #[cfg(test)]
 mod tests {
-    use client::UserStore;
     use client::test::FakeServer;
     use clock::FakeSystemClock;
     use cloud_api_types::{CreateLlmTokenResponse, LlmToken};
@@ -1770,10 +1628,15 @@ mod tests {
     use http_client::FakeHttpClient;
     use indoc::indoc;
     use language::Point;
+    use parking_lot::Mutex;
+    use serde_json::json;
     use settings::SettingsStore;
+    use util::path;
 
     use super::*;
 
+    const BSD_0_TXT: &str = include_str!("../license_examples/0bsd.txt");
+
     #[gpui::test]
     async fn test_edit_prediction_basic_interpolation(cx: &mut TestAppContext) {
         let buffer = cx.new(|cx| Buffer::local("Lorem ipsum dolor", cx));
@@ -1893,75 +1756,65 @@ mod tests {
 
     #[gpui::test]
     async fn test_clean_up_diff(cx: &mut TestAppContext) {
-        cx.update(|cx| {
-            let settings_store = SettingsStore::test(cx);
-            cx.set_global(settings_store);
-            client::init_settings(cx);
-        });
+        init_test(cx);
 
-        let edits = edits_for_prediction(
-            indoc! {"
-                fn main() {
-                    let word_1 = \"lorem\";
-                    let range = word.len()..word.len();
-                }
-            "},
+        assert_eq!(
+            apply_edit_prediction(
+                indoc! {"
+                    fn main() {
+                        let word_1 = \"lorem\";
+                        let range = word.len()..word.len();
+                    }
+                "},
+                indoc! {"
+                    <|editable_region_start|>
+                    fn main() {
+                        let word_1 = \"lorem\";
+                        let range = word_1.len()..word_1.len();
+                    }
+
+                    <|editable_region_end|>
+                "},
+                cx,
+            )
+            .await,
             indoc! {"
-                <|editable_region_start|>
                 fn main() {
                     let word_1 = \"lorem\";
                     let range = word_1.len()..word_1.len();
                 }
-
-                <|editable_region_end|>
             "},
-            cx,
-        )
-        .await;
-        assert_eq!(
-            edits,
-            [
-                (Point::new(2, 20)..Point::new(2, 20), "_1".to_string()),
-                (Point::new(2, 32)..Point::new(2, 32), "_1".to_string()),
-            ]
         );
 
-        let edits = edits_for_prediction(
-            indoc! {"
-                fn main() {
-                    let story = \"the quick\"
-                }
-            "},
+        assert_eq!(
+            apply_edit_prediction(
+                indoc! {"
+                    fn main() {
+                        let story = \"the quick\"
+                    }
+                "},
+                indoc! {"
+                    <|editable_region_start|>
+                    fn main() {
+                        let story = \"the quick brown fox jumps over the lazy dog\";
+                    }
+
+                    <|editable_region_end|>
+                "},
+                cx,
+            )
+            .await,
             indoc! {"
-                <|editable_region_start|>
                 fn main() {
                     let story = \"the quick brown fox jumps over the lazy dog\";
                 }
-
-                <|editable_region_end|>
             "},
-            cx,
-        )
-        .await;
-        assert_eq!(
-            edits,
-            [
-                (
-                    Point::new(1, 26)..Point::new(1, 26),
-                    " brown fox jumps over the lazy dog".to_string()
-                ),
-                (Point::new(1, 27)..Point::new(1, 27), ";".to_string()),
-            ]
         );
     }
 
     #[gpui::test]
     async fn test_edit_prediction_end_of_buffer(cx: &mut TestAppContext) {
-        cx.update(|cx| {
-            let settings_store = SettingsStore::test(cx);
-            cx.set_global(settings_store);
-            client::init_settings(cx);
-        });
+        init_test(cx);
 
         let buffer_content = "lorem\n";
         let completion_response = indoc! {"
@@ -1973,97 +1826,404 @@ mod tests {
             <|editable_region_end|>
             ```"};
 
-        let http_client = FakeHttpClient::create(move |req| async move {
-            match (req.method(), req.uri().path()) {
-                (&Method::POST, "/client/llm_tokens") => Ok(http_client::Response::builder()
-                    .status(200)
-                    .body(
-                        serde_json::to_string(&CreateLlmTokenResponse {
-                            token: LlmToken("the-llm-token".to_string()),
-                        })
-                        .unwrap()
-                        .into(),
-                    )
-                    .unwrap()),
-                (&Method::POST, "/predict_edits/v2") => Ok(http_client::Response::builder()
-                    .status(200)
-                    .body(
-                        serde_json::to_string(&PredictEditsResponse {
-                            request_id: Uuid::parse_str("7e86480f-3536-4d2c-9334-8213e3445d45")
-                                .unwrap(),
-                            output_excerpt: completion_response.to_string(),
-                        })
-                        .unwrap()
-                        .into(),
-                    )
-                    .unwrap()),
-                _ => Ok(http_client::Response::builder()
-                    .status(404)
-                    .body("Not Found".into())
-                    .unwrap()),
-            }
+        assert_eq!(
+            apply_edit_prediction(buffer_content, completion_response, cx).await,
+            "lorem\nipsum"
+        );
+    }
+
+    #[gpui::test]
+    async fn test_can_collect_data(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = project::FakeFs::new(cx.executor());
+        fs.insert_tree(path!("/project"), json!({ "LICENSE": BSD_0_TXT }))
+            .await;
+
+        let project = Project::test(fs.clone(), [path!("/project").as_ref()], cx).await;
+        let buffer = project
+            .update(cx, |project, cx| {
+                project.open_local_buffer(path!("/project/src/main.rs"), cx)
+            })
+            .await
+            .unwrap();
+
+        let (zeta, captured_request, _) = make_test_zeta(&project, cx).await;
+        zeta.update(cx, |zeta, _cx| {
+            zeta.data_collection_choice = DataCollectionChoice::Enabled
         });
 
-        let client = cx.update(|cx| Client::new(Arc::new(FakeSystemClock::new()), http_client, cx));
-        cx.update(|cx| {
-            RefreshLlmTokenListener::register(client.clone(), cx);
+        run_edit_prediction(&buffer, &project, &zeta, cx).await;
+        assert_eq!(
+            captured_request.lock().clone().unwrap().can_collect_data,
+            true
+        );
+
+        zeta.update(cx, |zeta, _cx| {
+            zeta.data_collection_choice = DataCollectionChoice::Disabled
         });
-        // Construct the fake server to authenticate.
-        let _server = FakeServer::for_client(42, &client, cx).await;
-        let user_store = cx.new(|cx| UserStore::new(client.clone(), cx));
-        let zeta = cx.new(|cx| Zeta::new(client, user_store.clone(), cx));
 
-        let buffer = cx.new(|cx| Buffer::local(buffer_content, cx));
-        let cursor = buffer.read_with(cx, |buffer, _| buffer.anchor_before(Point::new(1, 0)));
-        let completion_task = zeta.update(cx, |zeta, cx| {
-            zeta.request_completion(None, &buffer, cursor, false, cx)
+        run_edit_prediction(&buffer, &project, &zeta, cx).await;
+        assert_eq!(
+            captured_request.lock().clone().unwrap().can_collect_data,
+            false
+        );
+    }
+
+    #[gpui::test]
+    async fn test_no_data_collection_for_remote_file(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = project::FakeFs::new(cx.executor());
+        let project = Project::test(fs.clone(), [], cx).await;
+
+        let buffer = cx.new(|_cx| {
+            Buffer::remote(
+                language::BufferId::new(1).unwrap(),
+                1,
+                language::Capability::ReadWrite,
+                "fn main() {\n    println!(\"Hello\");\n}",
+            )
+        });
+
+        let (zeta, captured_request, _) = make_test_zeta(&project, cx).await;
+        zeta.update(cx, |zeta, _cx| {
+            zeta.data_collection_choice = DataCollectionChoice::Enabled
+        });
+
+        run_edit_prediction(&buffer, &project, &zeta, cx).await;
+        assert_eq!(
+            captured_request.lock().clone().unwrap().can_collect_data,
+            false
+        );
+    }
+
+    #[gpui::test]
+    async fn test_no_data_collection_for_private_file(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = project::FakeFs::new(cx.executor());
+        fs.insert_tree(
+            path!("/project"),
+            json!({
+                "LICENSE": BSD_0_TXT,
+                ".env": "SECRET_KEY=secret"
+            }),
+        )
+        .await;
+
+        let project = Project::test(fs.clone(), [path!("/project").as_ref()], cx).await;
+        let buffer = project
+            .update(cx, |project, cx| {
+                project.open_local_buffer("/project/.env", cx)
+            })
+            .await
+            .unwrap();
+
+        let (zeta, captured_request, _) = make_test_zeta(&project, cx).await;
+        zeta.update(cx, |zeta, _cx| {
+            zeta.data_collection_choice = DataCollectionChoice::Enabled
+        });
+
+        run_edit_prediction(&buffer, &project, &zeta, cx).await;
+        assert_eq!(
+            captured_request.lock().clone().unwrap().can_collect_data,
+            false
+        );
+    }
+
+    #[gpui::test]
+    async fn test_no_data_collection_for_untitled_buffer(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = project::FakeFs::new(cx.executor());
+        let project = Project::test(fs.clone(), [], cx).await;
+        let buffer = cx.new(|cx| Buffer::local("", cx));
+
+        let (zeta, captured_request, _) = make_test_zeta(&project, cx).await;
+        zeta.update(cx, |zeta, _cx| {
+            zeta.data_collection_choice = DataCollectionChoice::Enabled
+        });
+
+        run_edit_prediction(&buffer, &project, &zeta, cx).await;
+        assert_eq!(
+            captured_request.lock().clone().unwrap().can_collect_data,
+            false
+        );
+    }
+
+    #[gpui::test]
+    async fn test_no_data_collection_when_closed_source(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = project::FakeFs::new(cx.executor());
+        fs.insert_tree(path!("/project"), json!({ "main.rs": "fn main() {}" }))
+            .await;
+
+        let project = Project::test(fs.clone(), [path!("/project").as_ref()], cx).await;
+        let buffer = project
+            .update(cx, |project, cx| {
+                project.open_local_buffer("/project/main.rs", cx)
+            })
+            .await
+            .unwrap();
+
+        let (zeta, captured_request, _) = make_test_zeta(&project, cx).await;
+        zeta.update(cx, |zeta, _cx| {
+            zeta.data_collection_choice = DataCollectionChoice::Enabled
+        });
+
+        run_edit_prediction(&buffer, &project, &zeta, cx).await;
+        assert_eq!(
+            captured_request.lock().clone().unwrap().can_collect_data,
+            false
+        );
+    }
+
+    #[gpui::test]
+    async fn test_data_collection_status_changes_on_move(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = project::FakeFs::new(cx.executor());
+        fs.insert_tree(
+            path!("/open_source_worktree"),
+            json!({ "LICENSE": BSD_0_TXT, "main.rs": "" }),
+        )
+        .await;
+        fs.insert_tree(path!("/closed_source_worktree"), json!({ "main.rs": "" }))
+            .await;
+
+        let project = Project::test(
+            fs.clone(),
+            [
+                path!("/open_source_worktree").as_ref(),
+                path!("/closed_source_worktree").as_ref(),
+            ],
+            cx,
+        )
+        .await;
+        let buffer = project
+            .update(cx, |project, cx| {
+                project.open_local_buffer(path!("/open_source_worktree/main.rs"), cx)
+            })
+            .await
+            .unwrap();
+
+        let (zeta, captured_request, _) = make_test_zeta(&project, cx).await;
+        zeta.update(cx, |zeta, _cx| {
+            zeta.data_collection_choice = DataCollectionChoice::Enabled
         });
 
-        let completion = completion_task.await.unwrap().unwrap();
+        run_edit_prediction(&buffer, &project, &zeta, cx).await;
+        assert_eq!(
+            captured_request.lock().clone().unwrap().can_collect_data,
+            true
+        );
+
+        let closed_source_file = project
+            .update(cx, |project, cx| {
+                let worktree2 = project
+                    .worktree_for_root_name("closed_source_worktree", cx)
+                    .unwrap();
+                worktree2.update(cx, |worktree2, cx| {
+                    worktree2.load_file(Path::new("main.rs"), cx)
+                })
+            })
+            .await
+            .unwrap()
+            .file;
+
         buffer.update(cx, |buffer, cx| {
-            buffer.edit(completion.edits.iter().cloned(), None, cx)
+            buffer.file_updated(closed_source_file, cx);
         });
+
+        run_edit_prediction(&buffer, &project, &zeta, cx).await;
         assert_eq!(
-            buffer.read_with(cx, |buffer, _| buffer.text()),
-            "lorem\nipsum"
+            captured_request.lock().clone().unwrap().can_collect_data,
+            false
         );
     }
 
-    async fn edits_for_prediction(
+    #[gpui::test]
+    async fn test_no_data_collection_for_events_in_uncollectable_buffers(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = project::FakeFs::new(cx.executor());
+        fs.insert_tree(
+            path!("/worktree1"),
+            json!({ "LICENSE": BSD_0_TXT, "main.rs": "", "other.rs": "" }),
+        )
+        .await;
+        fs.insert_tree(path!("/worktree2"), json!({ "private.rs": "" }))
+            .await;
+
+        let project = Project::test(
+            fs.clone(),
+            [path!("/worktree1").as_ref(), path!("/worktree2").as_ref()],
+            cx,
+        )
+        .await;
+        let buffer = project
+            .update(cx, |project, cx| {
+                project.open_local_buffer(path!("/worktree1/main.rs"), cx)
+            })
+            .await
+            .unwrap();
+        let private_buffer = project
+            .update(cx, |project, cx| {
+                project.open_local_buffer(path!("/worktree2/file.rs"), cx)
+            })
+            .await
+            .unwrap();
+
+        let (zeta, captured_request, _) = make_test_zeta(&project, cx).await;
+        zeta.update(cx, |zeta, _cx| {
+            zeta.data_collection_choice = DataCollectionChoice::Enabled
+        });
+
+        run_edit_prediction(&buffer, &project, &zeta, cx).await;
+        assert_eq!(
+            captured_request.lock().clone().unwrap().can_collect_data,
+            true
+        );
+
+        // this has a side effect of registering the buffer to watch for edits
+        run_edit_prediction(&private_buffer, &project, &zeta, cx).await;
+        assert_eq!(
+            captured_request.lock().clone().unwrap().can_collect_data,
+            false
+        );
+
+        private_buffer.update(cx, |private_buffer, cx| {
+            private_buffer.edit([(0..0, "An edit for the history!")], None, cx);
+        });
+
+        run_edit_prediction(&buffer, &project, &zeta, cx).await;
+        assert_eq!(
+            captured_request.lock().clone().unwrap().can_collect_data,
+            false
+        );
+
+        // make an edit that uses too many bytes, causing private_buffer edit to not be able to be
+        // included
+        buffer.update(cx, |buffer, cx| {
+            buffer.edit(
+                [(0..0, " ".repeat(MAX_EVENT_TOKENS * BYTES_PER_TOKEN_GUESS))],
+                None,
+                cx,
+            );
+        });
+
+        run_edit_prediction(&buffer, &project, &zeta, cx).await;
+        assert_eq!(
+            captured_request.lock().clone().unwrap().can_collect_data,
+            true
+        );
+    }
+
+    fn init_test(cx: &mut TestAppContext) {
+        cx.update(|cx| {
+            let settings_store = SettingsStore::test(cx);
+            cx.set_global(settings_store);
+            language::init(cx);
+            client::init_settings(cx);
+            Project::init_settings(cx);
+        });
+    }
+
+    async fn apply_edit_prediction(
         buffer_content: &str,
         completion_response: &str,
         cx: &mut TestAppContext,
-    ) -> Vec<(Range<Point>, String)> {
-        let completion_response = completion_response.to_string();
-        let http_client = FakeHttpClient::create(move |req| {
-            let completion = completion_response.clone();
-            async move {
-                match (req.method(), req.uri().path()) {
-                    (&Method::POST, "/client/llm_tokens") => Ok(http_client::Response::builder()
-                        .status(200)
-                        .body(
-                            serde_json::to_string(&CreateLlmTokenResponse {
-                                token: LlmToken("the-llm-token".to_string()),
-                            })
-                            .unwrap()
-                            .into(),
-                        )
-                        .unwrap()),
-                    (&Method::POST, "/predict_edits/v2") => Ok(http_client::Response::builder()
-                        .status(200)
-                        .body(
-                            serde_json::to_string(&PredictEditsResponse {
-                                request_id: Uuid::new_v4(),
-                                output_excerpt: completion,
-                            })
-                            .unwrap()
-                            .into(),
-                        )
-                        .unwrap()),
-                    _ => Ok(http_client::Response::builder()
-                        .status(404)
-                        .body("Not Found".into())
-                        .unwrap()),
+    ) -> String {
+        let fs = project::FakeFs::new(cx.executor());
+        let project = Project::test(fs.clone(), [path!("/project").as_ref()], cx).await;
+        let buffer = cx.new(|cx| Buffer::local(buffer_content, cx));
+        let (zeta, _, response) = make_test_zeta(&project, cx).await;
+        *response.lock() = completion_response.to_string();
+        let edit_prediction = run_edit_prediction(&buffer, &project, &zeta, cx).await;
+        buffer.update(cx, |buffer, cx| {
+            buffer.edit(edit_prediction.edits.iter().cloned(), None, cx)
+        });
+        buffer.read_with(cx, |buffer, _| buffer.text())
+    }
+
+    async fn run_edit_prediction(
+        buffer: &Entity<Buffer>,
+        project: &Entity<Project>,
+        zeta: &Entity<Zeta>,
+        cx: &mut TestAppContext,
+    ) -> EditPrediction {
+        let cursor = buffer.read_with(cx, |buffer, _| buffer.anchor_before(Point::new(1, 0)));
+        zeta.update(cx, |zeta, cx| zeta.register_buffer(buffer, &project, cx));
+        cx.background_executor.run_until_parked();
+        let completion_task = zeta.update(cx, |zeta, cx| {
+            zeta.request_completion(&project, buffer, cursor, cx)
+        });
+        completion_task.await.unwrap().unwrap()
+    }
+
+    async fn make_test_zeta(
+        project: &Entity<Project>,
+        cx: &mut TestAppContext,
+    ) -> (
+        Entity<Zeta>,
+        Arc<Mutex<Option<PredictEditsBody>>>,
+        Arc<Mutex<String>>,
+    ) {
+        let default_response = indoc! {"
+            ```main.rs
+            <|start_of_file|>
+            <|editable_region_start|>
+            hello world
+            <|editable_region_end|>
+            ```"
+        };
+        let captured_request: Arc<Mutex<Option<PredictEditsBody>>> = Arc::new(Mutex::new(None));
+        let completion_response: Arc<Mutex<String>> =
+            Arc::new(Mutex::new(default_response.to_string()));
+        let http_client = FakeHttpClient::create({
+            let captured_request = captured_request.clone();
+            let completion_response = completion_response.clone();
+            move |req| {
+                let captured_request = captured_request.clone();
+                let completion_response = completion_response.clone();
+                async move {
+                    match (req.method(), req.uri().path()) {
+                        (&Method::POST, "/client/llm_tokens") => {
+                            Ok(http_client::Response::builder()
+                                .status(200)
+                                .body(
+                                    serde_json::to_string(&CreateLlmTokenResponse {
+                                        token: LlmToken("the-llm-token".to_string()),
+                                    })
+                                    .unwrap()
+                                    .into(),
+                                )
+                                .unwrap())
+                        }
+                        (&Method::POST, "/predict_edits/v2") => {
+                            let mut request_body = String::new();
+                            req.into_body().read_to_string(&mut request_body).await?;
+                            *captured_request.lock() =
+                                Some(serde_json::from_str(&request_body).unwrap());
+                            Ok(http_client::Response::builder()
+                                .status(200)
+                                .body(
+                                    serde_json::to_string(&PredictEditsResponse {
+                                        request_id: Uuid::new_v4(),
+                                        output_excerpt: completion_response.lock().clone(),
+                                    })
+                                    .unwrap()
+                                    .into(),
+                                )
+                                .unwrap())
+                        }
+                        _ => Ok(http_client::Response::builder()
+                            .status(404)
+                            .body("Not Found".into())
+                            .unwrap()),
+                    }
                 }
             }
         });
@@ -2072,24 +2232,23 @@ mod tests {
         cx.update(|cx| {
             RefreshLlmTokenListener::register(client.clone(), cx);
         });
-        // Construct the fake server to authenticate.
         let _server = FakeServer::for_client(42, &client, cx).await;
-        let user_store = cx.new(|cx| UserStore::new(client.clone(), cx));
-        let zeta = cx.new(|cx| Zeta::new(client, user_store.clone(), cx));
 
-        let buffer = cx.new(|cx| Buffer::local(buffer_content, cx));
-        let snapshot = buffer.read_with(cx, |buffer, _| buffer.snapshot());
-        let cursor = buffer.read_with(cx, |buffer, _| buffer.anchor_before(Point::new(1, 0)));
-        let completion_task = zeta.update(cx, |zeta, cx| {
-            zeta.request_completion(None, &buffer, cursor, false, cx)
+        let zeta = cx.new(|cx| {
+            let mut zeta = Zeta::new(client, project.read(cx).user_store(), cx);
+
+            let worktrees = project.read(cx).worktrees(cx).collect::<Vec<_>>();
+            for worktree in worktrees {
+                let worktree_id = worktree.read(cx).id();
+                zeta.license_detection_watchers
+                    .entry(worktree_id)
+                    .or_insert_with(|| Rc::new(LicenseDetectionWatcher::new(&worktree, cx)));
+            }
+
+            zeta
         });
 
-        let completion = completion_task.await.unwrap().unwrap();
-        completion
-            .edits
-            .iter()
-            .map(|(old_range, new_text)| (old_range.to_point(&snapshot), new_text.clone()))
-            .collect::<Vec<_>>()
+        (zeta, captured_request, completion_response)
     }
 
     fn to_completion_edits(
diff --git a/crates/zeta_cli/src/main.rs b/crates/zeta_cli/src/main.rs
index 5b2d4cf615be67d9493d617ae7de38fdc8fa4b2f..e7cec26b19358056cee4c8e253c54c0b2c794b33 100644
--- a/crates/zeta_cli/src/main.rs
+++ b/crates/zeta_cli/src/main.rs
@@ -10,7 +10,7 @@ use language::Bias;
 use language::Buffer;
 use language::Point;
 use language_model::LlmApiToken;
-use project::{Project, ProjectPath};
+use project::{Project, ProjectPath, Worktree};
 use release_channel::AppVersion;
 use reqwest_client::ReqwestClient;
 use std::path::{Path, PathBuf};
@@ -129,15 +129,33 @@ async fn get_context(
         return Err(anyhow!("Absolute paths are not supported in --cursor"));
     }
 
-    let (project, _lsp_open_handle, buffer) = if use_language_server {
-        let (project, lsp_open_handle, buffer) =
-            open_buffer_with_language_server(&worktree_path, &cursor.path, app_state, cx).await?;
-        (Some(project), Some(lsp_open_handle), buffer)
+    let project = cx.update(|cx| {
+        Project::local(
+            app_state.client.clone(),
+            app_state.node_runtime.clone(),
+            app_state.user_store.clone(),
+            app_state.languages.clone(),
+            app_state.fs.clone(),
+            None,
+            cx,
+        )
+    })?;
+
+    let worktree = project
+        .update(cx, |project, cx| {
+            project.create_worktree(&worktree_path, true, cx)
+        })?
+        .await?;
+
+    let (_lsp_open_handle, buffer) = if use_language_server {
+        let (lsp_open_handle, buffer) =
+            open_buffer_with_language_server(&project, &worktree, &cursor.path, cx).await?;
+        (Some(lsp_open_handle), buffer)
     } else {
         let abs_path = worktree_path.join(&cursor.path);
         let content = smol::fs::read_to_string(&abs_path).await?;
         let buffer = cx.new(|cx| Buffer::local(content, cx))?;
-        (None, None, buffer)
+        (None, buffer)
     };
 
     let worktree_name = worktree_path
@@ -171,56 +189,25 @@ async fn get_context(
         Some(events) => events.read_to_string().await?,
         None => String::new(),
     };
-    // Enable gathering extra data not currently needed for edit predictions
-    let can_collect_data = true;
-    let git_info = None;
-    let mut gather_context_output = cx
-        .update(|cx| {
-            gather_context(
-                project.as_ref(),
-                full_path_str,
-                &snapshot,
-                clipped_cursor,
-                move || events,
-                can_collect_data,
-                git_info,
-                cx,
-            )
-        })?
-        .await;
-
-    // Disable data collection for these requests, as this is currently just used for evals
-    if let Ok(gather_context_output) = gather_context_output.as_mut() {
-        gather_context_output.body.can_collect_data = false
-    }
-
-    gather_context_output
+    let prompt_for_events = move || (events, 0);
+    cx.update(|cx| {
+        gather_context(
+            full_path_str,
+            &snapshot,
+            clipped_cursor,
+            prompt_for_events,
+            cx,
+        )
+    })?
+    .await
 }
 
 pub async fn open_buffer_with_language_server(
-    worktree_path: &Path,
+    project: &Entity<Project>,
+    worktree: &Entity<Worktree>,
     path: &Path,
-    app_state: &Arc<ZetaCliAppState>,
     cx: &mut AsyncApp,
-) -> Result<(Entity<Project>, Entity<Entity<Buffer>>, Entity<Buffer>)> {
-    let project = cx.update(|cx| {
-        Project::local(
-            app_state.client.clone(),
-            app_state.node_runtime.clone(),
-            app_state.user_store.clone(),
-            app_state.languages.clone(),
-            app_state.fs.clone(),
-            None,
-            cx,
-        )
-    })?;
-
-    let worktree = project
-        .update(cx, |project, cx| {
-            project.create_worktree(worktree_path, true, cx)
-        })?
-        .await?;
-
+) -> Result<(Entity<Entity<Buffer>>, Entity<Buffer>)> {
     let project_path = worktree.read_with(cx, |worktree, _cx| ProjectPath {
         worktree_id: worktree.id(),
         path: path.to_path_buf().into(),
@@ -237,7 +224,7 @@ pub async fn open_buffer_with_language_server(
     let log_prefix = path.to_string_lossy().to_string();
     wait_for_lang_server(&project, &buffer, log_prefix, cx).await?;
 
-    Ok((project, lsp_open_handle, buffer))
+    Ok((lsp_open_handle, buffer))
 }
 
 // TODO: Dedupe with similar function in crates/eval/src/instance.rs
diff --git a/crates/zlog/src/filter.rs b/crates/zlog/src/filter.rs
index ee3c2410798b286795b9fd78b89502a2a7894987..31a58894774e6c0d08ea22b585350eb26ff09907 100644
--- a/crates/zlog/src/filter.rs
+++ b/crates/zlog/src/filter.rs
@@ -22,7 +22,7 @@ pub const LEVEL_ENABLED_MAX_DEFAULT: log::LevelFilter = log::LevelFilter::Info;
 /// crate that the max level is everything, so that we can dynamically enable
 /// logs that are more verbose than this level without the `log` crate throwing
 /// them away before we see them
-static mut LEVEL_ENABLED_MAX_STATIC: log::LevelFilter = LEVEL_ENABLED_MAX_DEFAULT;
+static LEVEL_ENABLED_MAX_STATIC: AtomicU8 = AtomicU8::new(LEVEL_ENABLED_MAX_DEFAULT as u8);
 
 /// A cache of the true maximum log level that _could_ be printed. This is based
 /// on the maximally verbose level that is configured by the user, and is used
@@ -46,7 +46,7 @@ const DEFAULT_FILTERS: &[(&str, log::LevelFilter)] = &[
 
 pub fn init_env_filter(filter: env_config::EnvFilter) {
     if let Some(level_max) = filter.level_global {
-        unsafe { LEVEL_ENABLED_MAX_STATIC = level_max }
+        LEVEL_ENABLED_MAX_STATIC.store(level_max as u8, Ordering::Release)
     }
     if ENV_FILTER.set(filter).is_err() {
         panic!("Environment filter cannot be initialized twice");
@@ -54,7 +54,7 @@ pub fn init_env_filter(filter: env_config::EnvFilter) {
 }
 
 pub fn is_possibly_enabled_level(level: log::Level) -> bool {
-    level as u8 <= LEVEL_ENABLED_MAX_CONFIG.load(Ordering::Relaxed)
+    level as u8 <= LEVEL_ENABLED_MAX_CONFIG.load(Ordering::Acquire)
 }
 
 pub fn is_scope_enabled(scope: &Scope, module_path: Option<&str>, level: log::Level) -> bool {
@@ -66,7 +66,7 @@ pub fn is_scope_enabled(scope: &Scope, module_path: Option<&str>, level: log::Le
         // scope map
         return false;
     }
-    let is_enabled_by_default = level <= unsafe { LEVEL_ENABLED_MAX_STATIC };
+    let is_enabled_by_default = level as u8 <= LEVEL_ENABLED_MAX_STATIC.load(Ordering::Acquire);
     let global_scope_map = SCOPE_MAP.read().unwrap_or_else(|err| {
         SCOPE_MAP.clear_poison();
         err.into_inner()
@@ -92,13 +92,13 @@ pub fn is_scope_enabled(scope: &Scope, module_path: Option<&str>, level: log::Le
 pub fn refresh_from_settings(settings: &HashMap<String, String>) {
     let env_config = ENV_FILTER.get();
     let map_new = ScopeMap::new_from_settings_and_env(settings, env_config, DEFAULT_FILTERS);
-    let mut level_enabled_max = unsafe { LEVEL_ENABLED_MAX_STATIC };
+    let mut level_enabled_max = LEVEL_ENABLED_MAX_STATIC.load(Ordering::Acquire);
     for entry in &map_new.entries {
         if let Some(level) = entry.enabled {
-            level_enabled_max = level_enabled_max.max(level);
+            level_enabled_max = level_enabled_max.max(level as u8);
         }
     }
-    LEVEL_ENABLED_MAX_CONFIG.store(level_enabled_max as u8, Ordering::Release);
+    LEVEL_ENABLED_MAX_CONFIG.store(level_enabled_max, Ordering::Release);
 
     {
         let mut global_map = SCOPE_MAP.write().unwrap_or_else(|err| {
diff --git a/crates/zlog/src/sink.rs b/crates/zlog/src/sink.rs
index 3ac85d4bbfc8aaa5d8568cb14b50e04a94708f1c..afbdf37bf9c74860a3b56b706ffc6d64338fd275 100644
--- a/crates/zlog/src/sink.rs
+++ b/crates/zlog/src/sink.rs
@@ -4,7 +4,7 @@ use std::{
     path::PathBuf,
     sync::{
         Mutex, OnceLock,
-        atomic::{AtomicU64, Ordering},
+        atomic::{AtomicBool, AtomicU64, Ordering},
     },
 };
 
@@ -19,17 +19,17 @@ const ANSI_GREEN: &str = "\x1b[32m";
 const ANSI_BLUE: &str = "\x1b[34m";
 const ANSI_MAGENTA: &str = "\x1b[35m";
 
-/// Whether stdout output is enabled.
-static mut ENABLED_SINKS_STDOUT: bool = false;
-/// Whether stderr output is enabled.
-static mut ENABLED_SINKS_STDERR: bool = false;
-
 /// Is Some(file) if file output is enabled.
 static ENABLED_SINKS_FILE: Mutex<Option<std::fs::File>> = Mutex::new(None);
 static SINK_FILE_PATH: OnceLock<&'static PathBuf> = OnceLock::new();
 static SINK_FILE_PATH_ROTATE: OnceLock<&'static PathBuf> = OnceLock::new();
+
+// NB: Since this can be accessed in tests, we probably should stick to atomics here.
+/// Whether stdout output is enabled.
+static ENABLED_SINKS_STDOUT: AtomicBool = AtomicBool::new(false);
+/// Whether stderr output is enabled.
+static ENABLED_SINKS_STDERR: AtomicBool = AtomicBool::new(false);
 /// Atomic counter for the size of the log file in bytes.
-// TODO: make non-atomic if writing single threaded
 static SINK_FILE_SIZE_BYTES: AtomicU64 = AtomicU64::new(0);
 /// Maximum size of the log file before it will be rotated, in bytes.
 const SINK_FILE_SIZE_BYTES_MAX: u64 = 1024 * 1024; // 1 MB
@@ -42,15 +42,13 @@ pub struct Record<'a> {
 }
 
 pub fn init_output_stdout() {
-    unsafe {
-        ENABLED_SINKS_STDOUT = true;
-    }
+    // Use atomics here instead of just a `static mut`, since in the context
+    // of tests these accesses can be multi-threaded.
+    ENABLED_SINKS_STDOUT.store(true, Ordering::Release);
 }
 
 pub fn init_output_stderr() {
-    unsafe {
-        ENABLED_SINKS_STDERR = true;
-    }
+    ENABLED_SINKS_STDERR.store(true, Ordering::Release);
 }
 
 pub fn init_output_file(
@@ -79,7 +77,7 @@ pub fn init_output_file(
     if size_bytes >= SINK_FILE_SIZE_BYTES_MAX {
         rotate_log_file(&mut file, Some(path), path_rotate, &SINK_FILE_SIZE_BYTES);
     } else {
-        SINK_FILE_SIZE_BYTES.store(size_bytes, Ordering::Relaxed);
+        SINK_FILE_SIZE_BYTES.store(size_bytes, Ordering::Release);
     }
 
     *enabled_sinks_file = Some(file);
@@ -108,7 +106,7 @@ static LEVEL_ANSI_COLORS: [&str; 6] = [
 
 // PERF: batching
 pub fn submit(record: Record) {
-    if unsafe { ENABLED_SINKS_STDOUT } {
+    if ENABLED_SINKS_STDOUT.load(Ordering::Acquire) {
         let mut stdout = std::io::stdout().lock();
         _ = writeln!(
             &mut stdout,
@@ -123,7 +121,7 @@ pub fn submit(record: Record) {
             },
             record.message
         );
-    } else if unsafe { ENABLED_SINKS_STDERR } {
+    } else if ENABLED_SINKS_STDERR.load(Ordering::Acquire) {
         let mut stdout = std::io::stderr().lock();
         _ = writeln!(
             &mut stdout,
@@ -173,7 +171,7 @@ pub fn submit(record: Record) {
                 },
                 record.message
             );
-            SINK_FILE_SIZE_BYTES.fetch_add(writer.written, Ordering::Relaxed) + writer.written
+            SINK_FILE_SIZE_BYTES.fetch_add(writer.written, Ordering::AcqRel) + writer.written
         };
         if file_size_bytes > SINK_FILE_SIZE_BYTES_MAX {
             rotate_log_file(
@@ -187,7 +185,7 @@ pub fn submit(record: Record) {
 }
 
 pub fn flush() {
-    if unsafe { ENABLED_SINKS_STDOUT } {
+    if ENABLED_SINKS_STDOUT.load(Ordering::Acquire) {
         _ = std::io::stdout().lock().flush();
     }
     let mut file = ENABLED_SINKS_FILE.lock().unwrap_or_else(|handle| {
@@ -265,7 +263,7 @@ fn rotate_log_file<PathRef>(
     // according to the documentation, it only fails if:
     // - the file is not writeable: should never happen,
     // - the size would cause an overflow (implementation specific): 0 should never cause an overflow
-    atomic_size.store(0, Ordering::Relaxed);
+    atomic_size.store(0, Ordering::Release);
 }
 
 #[cfg(test)]
@@ -298,7 +296,7 @@ mod tests {
             std::fs::read_to_string(&rotation_log_file_path).unwrap(),
             contents,
         );
-        assert_eq!(size.load(Ordering::Relaxed), 0);
+        assert_eq!(size.load(Ordering::Acquire), 0);
     }
 
     /// Regression test, ensuring that if log level values change we are made aware
diff --git a/crates/zlog_settings/src/zlog_settings.rs b/crates/zlog_settings/src/zlog_settings.rs
index 0cdc784489b47d89388edc9ed20aed6f3c2f9959..dd74fc574ff23dc78beca1feafeb34d874a68c22 100644
--- a/crates/zlog_settings/src/zlog_settings.rs
+++ b/crates/zlog_settings/src/zlog_settings.rs
@@ -3,7 +3,7 @@ use anyhow::Result;
 use gpui::App;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsStore, SettingsUi};
+use settings::{Settings, SettingsKey, SettingsStore, SettingsUi};
 
 pub fn init(cx: &mut App) {
     ZlogSettings::register(cx);
@@ -15,15 +15,25 @@ pub fn init(cx: &mut App) {
     .detach();
 }
 
-#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq, JsonSchema, SettingsUi)]
+#[derive(
+    Clone,
+    Debug,
+    Default,
+    Serialize,
+    Deserialize,
+    PartialEq,
+    Eq,
+    JsonSchema,
+    SettingsUi,
+    SettingsKey,
+)]
+#[settings_key(key = "log")]
 pub struct ZlogSettings {
     #[serde(default, flatten)]
     pub scopes: std::collections::HashMap<String, String>,
 }
 
 impl Settings for ZlogSettings {
-    const KEY: Option<&'static str> = Some("log");
-
     type FileContent = Self;
 
     fn load(sources: settings::SettingsSources<Self::FileContent>, _: &mut App) -> Result<Self>
diff --git a/docs/src/ai/agent-panel.md b/docs/src/ai/agent-panel.md
index ce91ca3401d07aba552b1ca007b3809e301071de..b6b748e2f58493cd62abbd3c6e7dc443182e992f 100644
--- a/docs/src/ai/agent-panel.md
+++ b/docs/src/ai/agent-panel.md
@@ -23,7 +23,7 @@ From this point on, you can interact with the many supported features outlined b
 
 > Note that for external agents, like [Gemini CLI](./external-agents.md#gemini-cli) or [Claude Code](./external-agents.md#claude-code), some of the features outlined below are _not_ currently supported—for example, _restoring threads from history_, _checkpoints_, _token usage display_, _model selection_, and others. All of them should hopefully be supported in the future.
 
-### Creating New Threads
+### Creating New Threads {#new-thread}
 
 By default, the Agent Panel uses Zed's first-party agent.
 
diff --git a/docs/src/ai/external-agents.md b/docs/src/ai/external-agents.md
index 963e41d42f53ad68ef70de3466913b71b11bd38e..bc7768c6081ad7a32eb1fd780750a48c4b9200f0 100644
--- a/docs/src/ai/external-agents.md
+++ b/docs/src/ai/external-agents.md
@@ -85,6 +85,12 @@ If you'd like to bind this to a keyboard shortcut, you can do so by editing your
 ]
 ```
 
+### Authentication
+
+As of version `0.202.7` (stable) and `0.203.2` (preview), authentication to Zed's Claude Code installation is decoupled entirely from Zed's agent. That is to say, an Anthropic API key added via the [Zed Agent's settings](./llm-providers.md#anthropic) will _not_ be utilized by Claude Code for authentication and billing.
+
+To ensure you're using your billing method of choice, [open a new Claude Code thread](./agent-panel.md#new-thread). Then, run `/login`, and authenticate either via API key, or via `Log in with Claude Code` to use a Claude Pro/Max subscription.
+
 #### Installation
 
 The first time you create a Claude Code thread, Zed will install [@zed-industries/claude-code-acp](https://github.com/zed-industries/claude-code-acp). This installation is only available to Zed and is kept up to date as you use the agent.
diff --git a/docs/src/configuring-languages.md b/docs/src/configuring-languages.md
index 52b7a3f7b82aeb3f2f19dcd63ef64c34251f1cd8..9da44fb53dba0ea044ce01ddb2d9ef3d90133adb 100644
--- a/docs/src/configuring-languages.md
+++ b/docs/src/configuring-languages.md
@@ -251,7 +251,7 @@ You can toggle language server support globally or per-language:
   }
 ```
 
-This disables the language server for Markdown files, which can be useful for performance in large documentation projects. You can configure this globally in your `~/.zed/settings.json` or inside a `.zed/settings.json` in your project directory.
+This disables the language server for Markdown files, which can be useful for performance in large documentation projects. You can configure this globally in your `~/.config/zed/settings.json` or inside a `.zed/settings.json` in your project directory.
 
 ## Formatting and Linting
 
diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index e245b3ca2facecb097b315f28d98ef2ea5a20048..c83dd84b881b4dd25c94bd795f49a937a7480d7c 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -116,7 +116,7 @@ Non-negative `float` values
 
 ## Allow Rewrap
 
-- Description: Controls where the `editor::Rewrap` action is allowed in the current language scope
+- Description: Controls where the {#action editor::Rewrap} action is allowed in the current language scope
 - Setting: `allow_rewrap`
 - Default: `"in_comments"`
 
@@ -178,7 +178,7 @@ Note: This setting has no effect in Vim mode, as rewrap is already allowed every
 
 You can find the names of your currently installed extensions by listing the subfolders under the [extension installation location](./extensions/installing-extensions.md#installation-location):
 
-On MacOS:
+On macOS:
 
 ```sh
 ls ~/Library/Application\ Support/Zed/extensions/installed/
@@ -294,7 +294,7 @@ Define extensions which should be installed (`true`) or never installed (`false`
 
 **Options**
 
-1. VSCode
+1. VS Code
 
 ```json
 {
@@ -326,7 +326,7 @@ Define extensions which should be installed (`true`) or never installed (`false`
 }
 ```
 
-5. SublimeText
+5. Sublime Text
 
 ```json
 {
@@ -2192,7 +2192,7 @@ Example:
 
 ## Go to Definition Fallback
 
-- Description: What to do when the "go to definition" action fails to find a definition
+- Description: What to do when the {#action editor::GoToDefinition} action fails to find a definition
 - Setting: `go_to_definition_fallback`
 - Default: `"find_all_references"`
 
@@ -2383,7 +2383,7 @@ Example:
 
 **Options**
 
-Run the `icon theme selector: toggle` action in the command palette to see a current list of valid icon themes names.
+Run the {#action icon_theme_selector::Toggle} action in the command palette to see a current list of valid icon themes names.
 
 ### Light
 
@@ -2393,7 +2393,7 @@ Run the `icon theme selector: toggle` action in the command palette to see a cur
 
 **Options**
 
-Run the `icon theme selector: toggle` action in the command palette to see a current list of valid icon themes names.
+Run the {#action icon_theme_selector::Toggle} action in the command palette to see a current list of valid icon themes names.
 
 ## Image Viewer
 
@@ -2469,7 +2469,7 @@ The following languages have inlay hints preconfigured by Zed:
 - [Go](https://docs.zed.dev/languages/go)
 - [Rust](https://docs.zed.dev/languages/rust)
 - [Svelte](https://docs.zed.dev/languages/svelte)
-- [Typescript](https://docs.zed.dev/languages/typescript)
+- [TypeScript](https://docs.zed.dev/languages/typescript)
 
 Use the `lsp` section for the server configuration. Examples are provided in the corresponding language documentation.
 
@@ -2699,7 +2699,7 @@ Positive `integer` values or `null` for unlimited tabs
 
 **Options**
 
-1. Maps to `Alt` on Linux and Windows and to `Option` on MacOS:
+1. Maps to `Alt` on Linux and Windows and to `Option` on macOS:
 
 ```json
 {
@@ -2707,7 +2707,7 @@ Positive `integer` values or `null` for unlimited tabs
 }
 ```
 
-2. Maps `Control` on Linux and Windows and to `Command` on MacOS:
+2. Maps `Control` on Linux and Windows and to `Command` on macOS:
 
 ```json
 {
@@ -2832,7 +2832,7 @@ Configuration object for defining settings profiles. Example:
 
   - Double-clicking on the file
   - Double-clicking on the tab header
-  - Using the `project_panel::OpenPermanent` action
+  - Using the {#action project_panel::OpenPermanent} action
   - Editing the file
   - Dragging the file to a different pane
 
@@ -4053,7 +4053,7 @@ Example command to set the title: `echo -e "\e]2;New Title\007";`
 
 **Options**
 
-Run the `theme selector: toggle` action in the command palette to see a current list of valid themes names.
+Run the {#action theme_selector::Toggle} action in the command palette to see a current list of valid themes names.
 
 ### Light
 
@@ -4063,7 +4063,7 @@ Run the `theme selector: toggle` action in the command palette to see a current
 
 **Options**
 
-Run the `theme selector: toggle` action in the command palette to see a current list of valid themes names.
+Run the {#action theme_selector::Toggle} action in the command palette to see a current list of valid themes names.
 
 ## Title Bar
 
@@ -4395,28 +4395,6 @@ Visit [the Configuration page](./ai/configuration.md) under the AI section to le
 - `dock`: Where to dock the collaboration panel. Can be `left` or `right`
 - `default_width`: Default width of the collaboration panel
 
-## Chat Panel
-
-- Description: Customizations for the chat panel.
-- Setting: `chat_panel`
-- Default:
-
-```json
-{
-  "chat_panel": {
-    "button": "when_in_call",
-    "dock": "right",
-    "default_width": 240
-  }
-}
-```
-
-**Options**
-
-- `button`: When to show the chat panel button in the status bar. Can be `never`, `always`, or `when_in_call`.
-- `dock`: Where to dock the chat panel. Can be 'left' or 'right'
-- `default_width`: Default width of the chat panel
-
 ## Debugger
 
 - Description: Configuration for debugger panel and settings
diff --git a/docs/src/development/debuggers.md b/docs/src/development/debuggers.md
index 1a0efd86d539c1c57dc5132f5728c5c2b8388451..a5713f6c8aae1123e48ab6ab9f85f2147dfc7819 100644
--- a/docs/src/development/debuggers.md
+++ b/docs/src/development/debuggers.md
@@ -93,9 +93,9 @@ rust-lldb -p <pid>
 
 Where `<pid>` is the process ID of the Zed instance you want to attach to.
 
-To get the process ID of a running Zed instance, you can use your systems process management tools such as `Task Manager` on windows or `Activity Monitor` on MacOS.
+To get the process ID of a running Zed instance, you can use your systems process management tools such as `Task Manager` on windows or `Activity Monitor` on macOS.
 
-Alternatively, you can run the `ps aux | grep zed` command on MacOS and Linux or `Get-Process | Select-Object Id, ProcessName` in an instance of PowerShell on Windows.
+Alternatively, you can run the `ps aux | grep zed` command on macOS and Linux or `Get-Process | Select-Object Id, ProcessName` in an instance of PowerShell on Windows.
 
 #### Debugging Panics and Crashes
 
diff --git a/docs/src/development/macos.md b/docs/src/development/macos.md
index c7e92623d4e226cb575da524fd8241fba3730fd6..851e2efdd7cdf15b9617445fe065149da8a5721f 100644
--- a/docs/src/development/macos.md
+++ b/docs/src/development/macos.md
@@ -33,7 +33,7 @@ Clone down the [Zed repository](https://github.com/zed-industries/zed).
 
 ### Backend Dependencies (optional) {#backend-dependencies}
 
-If you are looking to develop Zed collaboration features using a local collabortation server, please see: [Local Collaboration](./local-collaboration.md) docs.
+If you are looking to develop Zed collaboration features using a local collaboration server, please see: [Local Collaboration](./local-collaboration.md) docs.
 
 ## Building Zed from Source
 
diff --git a/docs/src/extensions/languages.md b/docs/src/extensions/languages.md
index 6756cb8a2309153a95edb23a24838295b1030266..376ac342f87252e6128e5107d057b32790c06e0a 100644
--- a/docs/src/extensions/languages.md
+++ b/docs/src/extensions/languages.md
@@ -269,7 +269,7 @@ The `textobjects.scm` file defines rules for navigating by text objects. This wa
 
 Vim provides two levels of granularity for navigating around files. Section-by-section with `[]` etc., and method-by-method with `]m` etc. Even languages that don't support functions and classes can work well by defining similar concepts. For example CSS defines a rule-set as a method, and a media-query as a class.
 
-For languages with closures, these typically should not count as functions in Zed. This is best-effort however, as languages like Javascript do not syntactically differentiate syntactically between closures and top-level function declarations.
+For languages with closures, these typically should not count as functions in Zed. This is best-effort however, as languages like JavaScript do not syntactically differentiate syntactically between closures and top-level function declarations.
 
 For languages with declarations like C, provide queries that match `@class.around` or `@function.around`. The `if` and `ic` text objects will default to these if there is no inside.
 
diff --git a/docs/src/globs.md b/docs/src/globs.md
index f3dfbc0acdef730997d0d9964e33f866ada3a4ad..4039d7c4556e24d0fb3ca30eafe8be05d13875bc 100644
--- a/docs/src/globs.md
+++ b/docs/src/globs.md
@@ -43,7 +43,7 @@ If you wanted to only search Markdown files add `*.md` to the "Include" search f
 
 ### Case insensitive matching
 
-Globs in Zed are case-sensitive, so `*.c` will not match `main.C` (even on case-insensitive filesystems like HFS+/APFS on MacOS). Instead use brackets to match characters. So instead of `*.c` use `*.[cC]`.
+Globs in Zed are case-sensitive, so `*.c` will not match `main.C` (even on case-insensitive filesystems like HFS+/APFS on macOS). Instead use brackets to match characters. So instead of `*.c` use `*.[cC]`.
 
 ### Matching directories
 
@@ -70,7 +70,7 @@ Alternatively, if in your Zed settings you wanted a [`file_types`](./configuring
 
 While globs in Zed are implemented as described above, when writing code using globs in other languages, please reference your platform's glob documentation:
 
-- [MacOS fnmatch](https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/fnmatch.3.html) (BSD C Standard Library)
+- [macOS fnmatch](https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/fnmatch.3.html) (BSD C Standard Library)
 - [Linux fnmatch](https://www.gnu.org/software/libc/manual/html_node/Wildcard-Matching.html) (GNU C Standard Library)
 - [POSIX fnmatch](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fnmatch.html) (POSIX Specification)
 - [node-glob](https://github.com/isaacs/node-glob) (Node.js `glob` package)
diff --git a/docs/src/helix.md b/docs/src/helix.md
index ddf997d3f085007176c0448af749229a3e1a6168..467a2fac7c373612bb867cc14f4b8a7a296ea9bd 100644
--- a/docs/src/helix.md
+++ b/docs/src/helix.md
@@ -9,3 +9,7 @@ For a guide on Vim-related features that are also available in Helix mode, pleas
 To check the current status of Helix mode, or to request a missing Helix feature, checkout out the ["Are we Helix yet?" discussion](https://github.com/zed-industries/zed/discussions/33580).
 
 For a detailed list of Helix's default keybindings, please visit the [official Helix documentation](https://docs.helix-editor.com/keymap.html).
+
+## Core differences
+
+Any text object that works with `m i` or `m a` also works with `]` and `[`, so for example `] (` selects the next pair of parentheses after the cursor.
diff --git a/docs/src/key-bindings.md b/docs/src/key-bindings.md
index 838dceaa8625d520fd8a7011883dcd39bd7d5dc8..e8ddbc46b29962e0bc20a54f94b6b3e0e2028214 100644
--- a/docs/src/key-bindings.md
+++ b/docs/src/key-bindings.md
@@ -1,28 +1,34 @@
 # Key bindings
 
-Zed has a very customizable key binding system — you can tweak everything to work exactly how your fingers expect!
+Zed has a very customizable key binding system—you can tweak everything to work exactly how your fingers expect!
 
 ## Predefined keymaps
 
-If you're used to a specific editor's defaults you can set a `base_keymap` in your [settings file](./configuring-zed.md). We currently have:
+If you're used to a specific editor's defaults, you can set a `base_keymap` in your [settings file](./configuring-zed.md).
+We currently support:
 
-- VSCode (default)
+- VS Code (default)
 - Atom
 - Emacs (Beta)
 - JetBrains
-- SublimeText
+- Sublime Text
 - TextMate
+- Cursor
 - None (disables _all_ key bindings)
 
-You can also enable `vim_mode` or `helix_mode`, which add modal bindings. For more information, see the documentation for [Vim mode](./vim.md) and [Helix mode](./helix.md).
+This setting can also be changed via the command palette through the `zed: toggle base keymap selector` action.
+
+You can also enable `vim_mode` or `helix_mode`, which add modal bindings.
+For more information, see the documentation for [Vim mode](./vim.md) and [Helix mode](./helix.md).
 
 ## User keymaps
 
-Zed reads your keymap from `~/.config/zed/keymap.json`. You can open the file within Zed with {#action zed::OpenKeymap} from the command palette or to spawn the Zed Keymap Editor ({#action zed::OpenKeymapEditor}) use {#kb zed::OpenKeymapEditor}.
+Zed reads your keymap from `~/.config/zed/keymap.json`, which you can open with the {#action zed::OpenKeymap} action from the command palette.
+You can also edit your keymap through the Zed Keymap Editor, accessible via the {#action zed::OpenKeymapEditor} action or the {#kb zed::OpenKeymapEditor} keybinding.
 
-The file contains a JSON array of objects with `"bindings"`. If no `"context"` is set the bindings are always active. If it is set the binding is only active when the [context matches](#contexts).
+The `keymap.json` file contains a JSON array of objects with `"bindings"`. If no `"context"` is set, the bindings are always active. If it is set, the binding is only active when the [context matches](#contexts).
 
-Within each binding section a [key sequence](#keybinding-syntax) is mapped to an [action](#actions). If conflicts are detected they are resolved as [described below](#precedence).
+Within each binding section, a [key sequence](#keybinding-syntax) is mapped to [an action](#actions). If conflicts are detected, they are resolved as [described below](#precedence).
 
 If you are using a non-QWERTY, Latin-character keyboard, you may want to set `use_key_equivalents` to `true`. See [Non-QWERTY keyboards](#non-qwerty-keyboards) for more information.
 
@@ -45,9 +51,9 @@ For example:
 ]
 ```
 
-You can see all of Zed's default bindings in the default keymaps for [MacOS](https://github.com/zed-industries/zed/blob/main/assets/keymaps/default-macos.json) or [Linux](https://github.com/zed-industries/zed/blob/main/assets/keymaps/default-linux.json).
+You can see all of Zed's default bindings in the default keymaps for [macOS](https://github.com/zed-industries/zed/blob/main/assets/keymaps/default-macos.json) or [Linux](https://github.com/zed-industries/zed/blob/main/assets/keymaps/default-linux.json).
 
-If you want to debug problems with custom keymaps you can use `dev: Open Key Context View` from the command palette. Please file [an issue](https://github.com/zed-industries/zed) if you run into something you think should work but isn't.
+If you want to debug problems with custom keymaps, you can use `dev: Open Key Context View` from the command palette. Please file [an issue](https://github.com/zed-industries/zed) if you run into something you think should work but isn't.
 
 ### Keybinding syntax
 
@@ -62,7 +68,7 @@ Each keypress is a sequence of modifiers followed by a key. The modifiers are:
 - `fn-` The function key
 - `secondary-` Equivalent to `cmd` when Zed is running on macOS and `ctrl` when on Windows and Linux
 
-The keys can be any single unicode codepoint that your keyboard generates (for example `a`, `0`, `£` or `ç`), or any named key (`tab`, `f1`, `shift`, or `cmd`). If you are using a non-Latin layout (e.g. Cyrillic), you can bind either to the cyrillic character, or the latin character that key generates with `cmd` pressed.
+The keys can be any single Unicode codepoint that your keyboard generates (for example `a`, `0`, `£` or `ç`), or any named key (`tab`, `f1`, `shift`, or `cmd`). If you are using a non-Latin layout (e.g. Cyrillic), you can bind either to the Cyrillic character or the Latin character that key generates with `cmd` pressed.
 
 A few examples:
 
@@ -75,17 +81,17 @@ A few examples:
  }
 ```
 
-The `shift-` modifier can only be used in combination with a letter to indicate the uppercase version. For example `shift-g` matches typing `G`. Although on many keyboards shift is used to type punctuation characters like `(`, the keypress is not considered to be modified and so `shift-(` does not match.
+The `shift-` modifier can only be used in combination with a letter to indicate the uppercase version. For example, `shift-g` matches typing `G`. Although on many keyboards shift is used to type punctuation characters like `(`, the keypress is not considered to be modified, and so `shift-(` does not match.
 
-The `alt-` modifier can be used on many layouts to generate a different key. For example on macOS US keyboard the combination `alt-c` types `ç`. You can match against either in your keymap file, though by convention Zed spells this combination as `alt-c`.
+The `alt-` modifier can be used on many layouts to generate a different key. For example, on a macOS US keyboard, the combination `alt-c` types `ç`. You can match against either in your keymap file, though by convention, Zed spells this combination as `alt-c`.
 
-It is possible to match against typing a modifier key on its own. For example `shift shift` can be used to implement JetBrains search everywhere shortcut. In this case the binding happens on key release instead of keypress.
+It is possible to match against typing a modifier key on its own. For example, `shift shift` can be used to implement JetBrains' 'Search Everywhere' shortcut. In this case, the binding happens on key release instead of on keypress.
 
 ### Contexts
 
-If a binding group has a `"context"` key it will be matched against the currently active contexts in Zed.
+If a binding group has a `"context"` key, it will be matched against the currently active contexts in Zed.
 
-Zed's contexts make up a tree, with the root being `Workspace`. Workspaces contain Panes and Panels, and Panes contain Editors, etc. The easiest way to see what contexts are active at a given moment is the key context view, which you can get to with `dev: Open Key Context View` in the command palette.
+Zed's contexts make up a tree, with the root being `Workspace`. Workspaces contain Panes and Panels, and Panes contain Editors, etc. The easiest way to see what contexts are active at a given moment is the key context view, which you can get to with the `dev: open key context view` command in the command palette.
 
 For example:
 
@@ -117,29 +123,25 @@ For example:
 
 It's worth noting that attributes are only available on the node they are defined on. This means that if you want to (for example) only enable a keybinding when the debugger is stopped in vim normal mode, you need to do `debugger_stopped > vim_mode == normal`.
 
-Note: Before Zed v0.197.x, the ! operator only looked at one node at a time, and `>` meant "parent" not "ancestor". This meant that `!Editor` would match the context `Workspace > Pane > Editor`, because (confusingly) the Pane matches `!Editor`, and that `os=macos > Editor` did not match the context `Workspace > Pane > Editor` because of the intermediate `Pane` node.
+> Note: Before Zed v0.197.x, the `!` operator only looked at one node at a time, and `>` meant "parent" not "ancestor". This meant that `!Editor` would match the context `Workspace > Pane > Editor`, because (confusingly) the Pane matches `!Editor`, and that `os=macos > Editor` did not match the context `Workspace > Pane > Editor` because of the intermediate `Pane` node.
 
 If you're using Vim mode, we have information on how [vim modes influence the context](./vim.md#contexts). Helix mode is built on top of Vim mode and uses the same contexts.
 
 ### Actions
 
-Pretty much all of Zed's functionality is exposed as actions. Although there is
-no explicitly documented list, you can find most of them by searching in the
-command palette, by looking in the default keymaps for
-[MacOS](https://github.com/zed-industries/zed/blob/main/assets/keymaps/default-macos.json)
-or
-[Linux](https://github.com/zed-industries/zed/blob/main/assets/keymaps/default-linux.json), or by using Zed's autocomplete in your keymap file.
+Almost all of Zed's functionality is exposed as actions.
+Although there is no explicitly documented list, you can find most of them by searching in the command palette, by looking in the default keymaps for [macOS](https://github.com/zed-industries/zed/blob/main/assets/keymaps/default-macos.json) or [Linux](https://github.com/zed-industries/zed/blob/main/assets/keymaps/default-linux.json), or by using Zed's autocomplete in your keymap file.
 
-Most actions do not require any arguments, and so you can bind them as strings: `"ctrl-a": "language_selector::Toggle"`. Some require a single argument, and must be bound as an array: `"cmd-1": ["workspace::ActivatePane", 0]`. Some actions require multiple arguments, and are bound as an array of a string and an object: `"ctrl-a": ["pane::DeploySearch", { "replace_enabled": true }]`.
+Most actions do not require any arguments, and so you can bind them as strings: `"ctrl-a": "language_selector::Toggle"`. Some require a single argument and must be bound as an array: `"cmd-1": ["workspace::ActivatePane", 0]`. Some actions require multiple arguments and are bound as an array of a string and an object: `"ctrl-a": ["pane::DeploySearch", { "replace_enabled": true }]`.
 
 ### Precedence
 
 When multiple keybindings have the same keystroke and are active at the same time, precedence is resolved in two ways:
 
-- Bindings that match on lower nodes in the context tree win. This means that if you have a binding with a context of `Editor` it will take precedence over a binding with a context of `Workspace`. Bindings with no context match at the lowest level in the tree.
-- If there are multiple bindings that match at the same level in the tree, then the binding defined later takes precedence. As user keybindings are loaded after system keybindings, this allows user bindings to take precedence over builtin keybindings.
+- Bindings that match on lower nodes in the context tree win. This means that if you have a binding with a context of `Editor`, it will take precedence over a binding with a context of `Workspace`. Bindings with no context match at the lowest level in the tree.
+- If there are multiple bindings that match at the same level in the tree, then the binding defined later takes precedence. As user keybindings are loaded after system keybindings, this allows user bindings to take precedence over built-in keybindings.
 
-The other kind of conflict that arises is when you have two bindings, one of which is a prefix of the other. For example if you have `"ctrl-w":"editor::DeleteToNextWordEnd"` and `"ctrl-w left":"editor::DeleteToEndOfLine"`.
+The other kind of conflict that arises is when you have two bindings, one of which is a prefix of the other. For example, if you have `"ctrl-w":"editor::DeleteToNextWordEnd"` and `"ctrl-w left":"editor::DeleteToEndOfLine"`.
 
 When this happens, and both bindings are active in the current context, Zed will wait for 1 second after you type `ctrl-w` to see if you're about to type `left`. If you don't type anything, or if you type a different key, then `DeleteToNextWordEnd` will be triggered. If you do, then `DeleteToEndOfLine` will be triggered.
 
@@ -147,15 +149,15 @@ When this happens, and both bindings are active in the current context, Zed will
 
 Zed's support for non-QWERTY keyboards is still a work in progress.
 
-If your keyboard can type the full ASCII ranges (DVORAK, COLEMAK, etc.) then shortcuts should work as you expect.
+If your keyboard can type the full ASCII range (DVORAK, COLEMAK, etc.), then shortcuts should work as you expect.
 
 Otherwise, read on...
 
 #### macOS
 
-On Cyrillic, Hebrew, Armenian, and other keyboards that are mostly non-ASCII; macOS automatically maps keys to the ASCII range when `cmd` is held. Zed takes this a step further and it can always match key-presses against either the ASCII layout, or the real layout regardless of modifiers, and regardless of the `use_key_equivalents` setting. For example in Thai, pressing `ctrl-ๆ` will match bindings associated with `ctrl-q` or `ctrl-ๆ`
+On Cyrillic, Hebrew, Armenian, and other keyboards that are mostly non-ASCII, macOS automatically maps keys to the ASCII range when `cmd` is held. Zed takes this a step further, and it can always match key-presses against either the ASCII layout or the real layout, regardless of modifiers and the `use_key_equivalents` setting. For example, in Thai, pressing `ctrl-ๆ` will match bindings associated with `ctrl-q` or `ctrl-ๆ`.
 
-On keyboards that support extended Latin alphabets (French AZERTY, German QWERTZ, etc.) it is often not possible to type the entire ASCII range without `option`. This introduces an ambiguity, `option-2` produces `@`. To ensure that all the builtin keyboard shortcuts can still be typed on these keyboards we move key-bindings around. For example, shortcuts bound to `@` on QWERTY are moved to `"` on a Spanish layout. This mapping is based on the macOS system defaults and can be seen by running `dev: Open Key Context View` from the command palette.
+On keyboards that support extended Latin alphabets (French AZERTY, German QWERTZ, etc.), it is often not possible to type the entire ASCII range without `option`. This introduces an ambiguity: `option-2` produces `@`. To ensure that all the built-in keyboard shortcuts can still be typed on these keyboards, we move key bindings around. For example, shortcuts bound to `@` on QWERTY are moved to `"` on a Spanish layout. This mapping is based on the macOS system defaults and can be seen by running `dev: open key context view` from the command palette.
 
 If you are defining shortcuts in your personal keymap, you can opt into the key equivalent mapping by setting `use_key_equivalents` to `true` in your keymap:
 
@@ -172,16 +174,16 @@ If you are defining shortcuts in your personal keymap, you can opt into the key
 
 ### Linux
 
-Since v0.196.0 on Linux if the key that you type doesn't produce an ASCII character then we use the QWERTY-layout equivalent key for keyboard shortcuts. This means that many shortcuts can be typed on many layouts.
+Since v0.196.0, on Linux, if the key that you type doesn't produce an ASCII character, then we use the QWERTY-layout equivalent key for keyboard shortcuts. This means that many shortcuts can be typed on many layouts.
 
-We do not yet move shortcuts around to ensure that all the builtin shortcuts can be typed on every layout; so if there are some ASCII characters that cannot be typed, and your keyboard layout has different ASCII characters on the same keys as would be needed to type them, you may need to add custom key bindings to make this work. We do intend to fix this at some point, and help is very much wanted!
+We do not yet move shortcuts around to ensure that all the built-in shortcuts can be typed on every layout, so if there are some ASCII characters that cannot be typed, and your keyboard layout has different ASCII characters on the same keys as would be needed to type them, you may need to add custom key bindings to make this work. We do intend to fix this at some point, and help is very much appreciated!
 
 ## Tips and tricks
 
 ### Disabling a binding
 
-If you'd like a given binding to do nothing in a given context you can use
-`null` as the action. This is useful if you hit the keybinding by accident and
+If you'd like a given binding to do nothing in a given context, you can use
+`null` as the action. This is useful if you hit the key binding by accident and
 want to disable it, or if you want to type the character that would be typed by
 the sequence, or if you want to disable multikey bindings starting with that key.
 
@@ -196,9 +198,9 @@ the sequence, or if you want to disable multikey bindings starting with that key
 ]
 ```
 
-A `null` binding follows the same precedence rules as normal actions. So disables all bindings that would match further up in the tree too. If you'd like a binding that matches further up in the tree to take precedence over a lower binding, you need to rebind it to the action you want in the context you want.
+A `null` binding follows the same precedence rules as normal actions, so it disables all bindings that would match further up in the tree too. If you'd like a binding that matches further up in the tree to take precedence over a lower binding, you need to rebind it to the action you want in the context you want.
 
-This is useful for preventing Zed from falling back to a default keybinding when the action you specified is conditional and propagates. For example, `buffer_search::DeployReplace` only triggers when the search bar is not in view. If the search bar is in view, it would propagate and trigger the default action set for that binding, such as opening the right dock. To prevent this from happening:
+This is useful for preventing Zed from falling back to a default key binding when the action you specified is conditional and propagates. For example, `buffer_search::DeployReplace` only triggers when the search bar is not in view. If the search bar is in view, it would propagate and trigger the default action set for that key binding, such as opening the right dock. To prevent this from happening:
 
 ```json
 [
@@ -246,7 +248,7 @@ A common request is to be able to map from a single keystroke to a sequence. You
 
 There are some limitations to this, notably:
 
-- Any asynchronous operation will not happen until after all your key bindings have been dispatched. For example this means that while you can use a binding to open a file (as in the `cmd-alt-r` example) you cannot send further keystrokes and hope to have them interpreted by the new view.
+- Any asynchronous operation will not happen until after all your key bindings have been dispatched. For example, this means that while you can use a binding to open a file (as in the `cmd-alt-r` example), you cannot send further keystrokes and hope to have them interpreted by the new view.
 - Other examples of asynchronous things are: opening the command palette, communicating with a language server, changing the language of a buffer, anything that hits the network.
 - There is a limit of 100 simulated keys at a time.
 
@@ -271,5 +273,5 @@ For example, `ctrl-n` creates a new tab in Zed on Linux. If you want to send `ct
 
 ### Task Key bindings
 
-You can also bind keys to launch Zed Tasks defined in your tasks.json.
+You can also bind keys to launch Zed Tasks defined in your `tasks.json`.
 See the [tasks documentation](tasks.md#custom-keybindings-for-tasks) for more.
diff --git a/docs/src/languages/c.md b/docs/src/languages/c.md
index 8db1bb671257397f0bcf668af374d700142db658..849ce6a662e291659d27d05deea3aa95f51b0161 100644
--- a/docs/src/languages/c.md
+++ b/docs/src/languages/c.md
@@ -8,14 +8,14 @@ C support is available natively in Zed.
 
 ## Clangd: Force detect as C
 
-Clangd out of the box assumes mixed C++/C projects. If you have a C-only project you may wish to instruct clangd to all files as C using the `-xc` flag. To do this, create a `.clangd` file in the root of your project with the following:
+Clangd out of the box assumes mixed C++/C projects. If you have a C-only project you may wish to instruct clangd to treat all files as C using the `-xc` flag. To do this, create a `.clangd` file in the root of your project with the following:
 
 ```yaml
 CompileFlags:
   Add: [-xc]
 ```
 
-By default clang and gcc by will recognize `*.C` and `*.H` (uppercase extensions) as C++ and not C and so Zed too follows this convention. If you are working with a C-only project (perhaps one with legacy uppercase pathing like `FILENAME.C`) you can override this behavior by adding this to your settings:
+By default clang and gcc will recognize `*.C` and `*.H` (uppercase extensions) as C++ and not C and so Zed too follows this convention. If you are working with a C-only project (perhaps one with legacy uppercase pathing like `FILENAME.C`) you can override this behavior by adding this to your settings:
 
 ```json
 {
diff --git a/docs/src/languages/cpp.md b/docs/src/languages/cpp.md
index 91395b5a94ca3e84699edcb731209ca9e260753c..fe2eb9c1f911bc2457862d2d94d6d489cb1b3d49 100644
--- a/docs/src/languages/cpp.md
+++ b/docs/src/languages/cpp.md
@@ -44,7 +44,7 @@ If you want to use a binary in a custom location, you can specify a `path` and o
 ```json
 {
   "lsp": {
-    "cangd": {
+    "clangd": {
       "binary": {
         "path": "/path/to/clangd",
         "arguments": []
diff --git a/docs/src/languages/deno.md b/docs/src/languages/deno.md
index c40b6531e62142de6a9597528ba1e6a4879c16e3..12d36b9ef851d4a21a46601ba8aa46edcc6de7d5 100644
--- a/docs/src/languages/deno.md
+++ b/docs/src/languages/deno.md
@@ -54,7 +54,7 @@ To use the Deno Language Server with TypeScript and TSX files, you will likely w
 See [Configuring supported languages](../configuring-languages.md) in the Zed documentation for more information.
 
 <!--
-TBD: Deno Typescript REPL instructions [docs/repl#typescript-deno](../repl.md#typescript-deno)
+TBD: Deno TypeScript REPL instructions [docs/repl#typescript-deno](../repl.md#typescript-deno)
 -->
 
 ## DAP support
diff --git a/docs/src/languages/gdscript.md b/docs/src/languages/gdscript.md
index 3786518b20920daf494d854db5ee48ff5f687452..3b779fc8909f570855f240735df6e360c1e22052 100644
--- a/docs/src/languages/gdscript.md
+++ b/docs/src/languages/gdscript.md
@@ -8,7 +8,7 @@ Report issues to: [https://github.com/grndctrl/zed-gdscript/issues](https://gith
 
 ## Setup
 
-1. Download and install [Godot for MacOS](https://godotengine.org/download/macos/).
+1. Download and install [Godot for macOS](https://godotengine.org/download/macos/).
 2. Unzip the Godot.app and drag it into your /Applications folder.
 3. Open Godot.app and open your project (an example project is fine)
 4. In Godot, Editor Menu -> Editor Settings; scroll down the left sidebar to `Text Editor -> External`
diff --git a/docs/src/languages/java.md b/docs/src/languages/java.md
index 0312cb3bd7e8b14ccedee7aacded456cc3e06e97..31177676854884be804838ddf72f937fc9376f71 100644
--- a/docs/src/languages/java.md
+++ b/docs/src/languages/java.md
@@ -10,7 +10,7 @@ Java language support in Zed is provided by:
 
 You will need to install a Java runtime (OpenJDK).
 
-- MacOS: `brew install openjdk`
+- macOS: `brew install openjdk`
 - Ubuntu: `sudo add-apt-repository ppa:openjdk-23 && sudo apt-get install openjdk-23`
 - Windows: `choco install openjdk`
 - Arch Linux: `sudo pacman -S jre-openjdk-headless`
@@ -154,7 +154,7 @@ There are also many more options you can pass directly to the language server, f
 
 If you prefer, you can install JDTLS yourself and the extension can be configured to use that instead.
 
-- MacOS: `brew install jdtls`
+- macOS: `brew install jdtls`
 - Arch: [`jdtls` from AUR](https://aur.archlinux.org/packages/jdtls)
 
 Or manually download install:
diff --git a/docs/src/languages/lua.md b/docs/src/languages/lua.md
index 8fdaaafedb80af3c9f466e2fdfd44959364a8789..7e92b12b919ef2537b0fa6785a6438ef0039deda 100644
--- a/docs/src/languages/lua.md
+++ b/docs/src/languages/lua.md
@@ -18,7 +18,7 @@ To configure LuaLS you can create a `.luarc.json` file in the root of your works
 }
 ```
 
-See [LuaLS Settings Documentation](https://luals.github.io/wiki/settings/) for all available configuration options, or when editing this file in Zed available settings options will autocomplete, (e.g `runtime.version` will show `"Lua 5.1"`, `"Lua 5.2"`, `"Lua 5.3"`, `"Lua 5.4"` and `"LuaJIT"` as allowed values). Note when importing settings options from VSCode, remove the `Lua.` prefix. (e.g. `runtime.version` instead of `Lua.runtime.version`).
+See [LuaLS Settings Documentation](https://luals.github.io/wiki/settings/) for all available configuration options, or when editing this file in Zed available settings options will autocomplete, (e.g `runtime.version` will show `"Lua 5.1"`, `"Lua 5.2"`, `"Lua 5.3"`, `"Lua 5.4"` and `"LuaJIT"` as allowed values). Note when importing settings options from VS Code, remove the `Lua.` prefix. (e.g. `runtime.version` instead of `Lua.runtime.version`).
 
 ### LuaCATS Definitions
 
diff --git a/docs/src/languages/rust.md b/docs/src/languages/rust.md
index c8dd1ac550150573a6e476b75b1cee4645a49619..359af7737161a8dff388b0ef849183504fe29207 100644
--- a/docs/src/languages/rust.md
+++ b/docs/src/languages/rust.md
@@ -112,7 +112,7 @@ This `"path"` has to be an absolute path.
 
 ## Alternate Targets
 
-If want rust-analyzer to provide diagnostics for a target other than you current platform (e.g. for windows when running on macOS) you can use the following Zed lsp settings:
+If you want rust-analyzer to provide diagnostics for a target other than your current platform (e.g. for windows when running on macOS) you can use the following Zed lsp settings:
 
 ```json
 {
@@ -128,7 +128,7 @@ If want rust-analyzer to provide diagnostics for a target other than you current
 }
 ```
 
-If you are using `rustup` and you can find a list of available target triples (`aarch64-apple-darwin`, `x86_64-unknown-linux-gnu`, etc) by running:
+If you are using `rustup`, you can find a list of available target triples (`aarch64-apple-darwin`, `x86_64-unknown-linux-gnu`, etc) by running:
 
 ```sh
 rustup target list --installed
@@ -239,7 +239,7 @@ you can list them in `linkedProjects` in the local project settings:
 
 ### Snippets
 
-There's a way get custom completion items from rust-analyzer, that will transform the code according to the snippet body:
+There's a way to get custom completion items from rust-analyzer, that will transform the code according to the snippet body:
 
 ```json
 {
diff --git a/docs/src/languages/toml.md b/docs/src/languages/toml.md
index eb51dbb93bf3031449744ccd4617992f46d31351..46b93b67eb4ba85dea0c297adbfe1a261b6a22dc 100644
--- a/docs/src/languages/toml.md
+++ b/docs/src/languages/toml.md
@@ -1,22 +1,7 @@
 # TOML
 
-TOML support is available through the [TOML extension](https://github.com/zed-industries/zed/tree/main/extensions/toml).
+TOML support is available through the [TOML extension](https://zed.dev/extensions/toml).
 
 - Tree-sitter: [tree-sitter/tree-sitter-toml](https://github.com/tree-sitter/tree-sitter-toml)
-- Language Server: [tamasfe/taplo](https://github.com/tamasfe/taplo)
 
-## Configuration
-
-You can control the behavior of the Taplo TOML language server by adding a `.taplo.toml` file to the root of your project. See the [Taplo Configuration File](https://taplo.tamasfe.dev/configuration/file.html#configuration-file) and [Taplo Formatter Options](https://taplo.tamasfe.dev/configuration/formatter-options.html) documentation for more.
-
-```toml
-# .taplo.toml
-[formatting]
-align_comments = false
-reorder_keys = true
-
-include = ["Cargo.toml", "some_directory/**/*.toml"]
-# exclude = ["vendor/**/*.toml"]
-```
-
-Note: The taplo language server will not automatically pickup changes to `.taplo.toml`. You must manually trigger {#action editor::RestartLanguageServer} or reload Zed for it to pickup changes.
+A TOML language server is available in the [Tombi extension](https://zed.dev/extensions/tombi).
diff --git a/docs/src/languages/yarn.md b/docs/src/languages/yarn.md
index 57e2ce2aa4bdc99ca2aa22ffb71e55f957da1641..3bb7bd6ae9441340ed28a1a745445113535e9627 100644
--- a/docs/src/languages/yarn.md
+++ b/docs/src/languages/yarn.md
@@ -5,5 +5,5 @@
 ## Setup
 
 1. Run `yarn dlx @yarnpkg/sdks base` to generate a `.yarn/sdks` directory.
-2. Set your language server (e.g. VTSLS) to use Typescript SDK from `.yarn/sdks/typescript/lib` directory in [LSP initialization options](../configuring-zed.md#lsp). The actual setting for that depends on language server; for example, for VTSLS you should set [`typescript.tsdk`](https://github.com/yioneko/vtsls/blob/6adfb5d3889ad4b82c5e238446b27ae3ee1e3767/packages/service/configuration.schema.json#L5).
+2. Set your language server (e.g. VTSLS) to use TypeScript SDK from `.yarn/sdks/typescript/lib` directory in [LSP initialization options](../configuring-zed.md#lsp). The actual setting for that depends on language server; for example, for VTSLS you should set [`typescript.tsdk`](https://github.com/yioneko/vtsls/blob/6adfb5d3889ad4b82c5e238446b27ae3ee1e3767/packages/service/configuration.schema.json#L5).
 3. Voilla! Language server functionalities such as Go to Definition, Code Completions and On Hover documentation should work.
diff --git a/docs/src/repl.md b/docs/src/repl.md
index 9c14ff925fd59b30d70087ed402627b5122c6e3a..92b3d81f24fd7c8c238b56f8681b0b62d0ff93c1 100644
--- a/docs/src/repl.md
+++ b/docs/src/repl.md
@@ -114,7 +114,7 @@ ark --install
 TBD: Improve R REPL (Ark Kernel) instructions
 -->
 
-### Typescript: Deno {#typescript-deno}
+### TypeScript: Deno {#typescript-deno}
 
 - [Install Deno](https://docs.deno.com/runtime/manual/getting_started/installation/) and then install the Deno jupyter kernel:
 
diff --git a/docs/src/snippets.md b/docs/src/snippets.md
index 3514d08340e8f1d04287ffde0150281149625476..6dc5355907bec47c4bd4f86353c226201bb49586 100644
--- a/docs/src/snippets.md
+++ b/docs/src/snippets.md
@@ -31,7 +31,7 @@ The scope is determined by the language name in lowercase e.g. `python.json` for
 | JSX        | javascript.json |
 | Plain Text | plaintext.json  |
 
-To create JSX snippets you have to use `javascript.json` snippets file, instead of `jsx.json`, but this does not apply to TSX and Typescript which follow the above rule.
+To create JSX snippets you have to use `javascript.json` snippets file, instead of `jsx.json`, but this does not apply to TSX and TypeScript which follow the above rule.
 
 ## Known Limitations
 
@@ -40,4 +40,20 @@ To create JSX snippets you have to use `javascript.json` snippets file, instead
 
 ## See also
 
+The `feature_paths` option in `simple-completion-language-server` is disabled by default.
+
+If you want to enable it you can add the following to your `settings.json`:
+
+```json
+{
+  "lsp": {
+    "snippet-completion-server": {
+      "settings": {
+        "feature_paths": true
+      }
+    }
+  }
+}
+```
+
 For more configuration information, see the [`simple-completion-language-server` instructions](https://github.com/zed-industries/simple-completion-language-server/tree/main).
diff --git a/docs/src/tasks.md b/docs/src/tasks.md
index bff3eac86048752be50f8fd605bc5b76677ca0c0..e530f568cdce0fb8e1da059b4b841fac7049e8fd 100644
--- a/docs/src/tasks.md
+++ b/docs/src/tasks.md
@@ -45,7 +45,7 @@ Zed supports ways to spawn (and rerun) commands using its integrated terminal to
     // Whether to show the task line in the output of the spawned task, defaults to `true`.
     "show_summary": true,
     // Whether to show the command line in the output of the spawned task, defaults to `true`.
-    "show_output": true
+    "show_command": true
     // Represents the tags for inline runnable indicators, or spawning multiple tasks at once.
     // "tags": []
   }
diff --git a/docs/src/visual-customization.md b/docs/src/visual-customization.md
index 47c72e80f5ea0ca6ce8576e29c51ff9e44041eb5..073911fd60d441c38c361144e033591b3eed433a 100644
--- a/docs/src/visual-customization.md
+++ b/docs/src/visual-customization.md
@@ -94,7 +94,6 @@ To disable this behavior use:
   // "project_panel": {"button": false },
   // "outline_panel": {"button": false },
   // "collaboration_panel": {"button": false },
-  // "chat_panel": {"button": "never" },
   // "git_panel": {"button": false },
   // "notification_panel": {"button": false },
   // "agent": {"button": false },
@@ -554,13 +553,6 @@ See [Terminal settings](./configuring-zed.md#terminal) for additional non-visual
   },
   "show_call_status_icon": true,  // Shown call status in the OS status bar.
 
-  // Chat Panel
-  "chat_panel": {
-    "button": "when_in_call",     // status bar icon (true, false, when_in_call)
-    "dock": "right",              // Where to dock: left, right
-    "default_width": 240          // Default width of the chat panel
-  },
-
   // Notification Panel
   "notification_panel": {
     // Whether to show the notification panel button in the status bar.
diff --git a/extensions/snippets/Cargo.toml b/extensions/snippets/Cargo.toml
index 80a3d4f31ebd628f03b077c727527b5aa0057ebf..ab5ac7244a3acbe25246588f4fe4ad1a35f1964f 100644
--- a/extensions/snippets/Cargo.toml
+++ b/extensions/snippets/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "zed_snippets"
-version = "0.0.5"
+version = "0.0.6"
 edition.workspace = true
 publish.workspace = true
 license = "Apache-2.0"
diff --git a/extensions/snippets/extension.toml b/extensions/snippets/extension.toml
index c2b4178a614220872bca37e4c2a12f4b16bba82f..01dc587d77af8a9ca074b49a247ef8f6cfffb516 100644
--- a/extensions/snippets/extension.toml
+++ b/extensions/snippets/extension.toml
@@ -1,9 +1,9 @@
 id = "snippets"
 name = "Snippets"
 description = "Support for language-agnostic snippets, provided by simple-completion-language-server"
-version = "0.0.5"
+version = "0.0.6"
 schema_version = 1
-authors = []
+authors = ["Zed Industries <hi@zed.dev>"]
 repository = "https://github.com/zed-industries/zed"
 
 [language_servers.snippet-completion-server]
diff --git a/extensions/snippets/src/snippets.rs b/extensions/snippets/src/snippets.rs
index 05e1ebca38ddfa576795e6040ccd2b3dde20cc3e..1efe4c234002b5c8b3d26b9bdb0b30095e212ea6 100644
--- a/extensions/snippets/src/snippets.rs
+++ b/extensions/snippets/src/snippets.rs
@@ -120,7 +120,9 @@ impl zed::Extension for SnippetExtension {
                     "snippets_first": true,
                     "feature_words": false,
                     "feature_snippets": true,
-                    "feature_paths": true
+                    // We disable `feature_paths` by default, because it's bad UX to assume that any `/` that is typed
+                    // is the start of a path.
+                    "feature_paths": false
                 })
             });
         Ok(Some(settings))
diff --git a/extensions/toml/Cargo.toml b/extensions/toml/Cargo.toml
deleted file mode 100644
index 25c2c418084dc89fe4c402c1abe13d5535bf6447..0000000000000000000000000000000000000000
--- a/extensions/toml/Cargo.toml
+++ /dev/null
@@ -1,16 +0,0 @@
-[package]
-name = "zed_toml"
-version = "0.1.4"
-edition.workspace = true
-publish.workspace = true
-license = "Apache-2.0"
-
-[lints]
-workspace = true
-
-[lib]
-path = "src/toml.rs"
-crate-type = ["cdylib"]
-
-[dependencies]
-zed_extension_api = "0.1.0"
diff --git a/extensions/toml/extension.toml b/extensions/toml/extension.toml
deleted file mode 100644
index 5be7213c40362ec4bbeba8cb0846a507d9ec9e7e..0000000000000000000000000000000000000000
--- a/extensions/toml/extension.toml
+++ /dev/null
@@ -1,18 +0,0 @@
-id = "toml"
-name = "TOML"
-description = "TOML support."
-version = "0.1.4"
-schema_version = 1
-authors = [
-    "Max Brunsfeld <max@zed.dev>",
-    "Ammar Arif <evergreenkary@gmail.com>"
-]
-repository = "https://github.com/zed-industries/zed"
-
-[language_servers.taplo]
-name = "Taplo"
-language = "TOML"
-
-[grammars.toml]
-repository = "https://github.com/tree-sitter/tree-sitter-toml"
-commit = "342d9be207c2dba869b9967124c679b5e6fd0ebe"
diff --git a/extensions/toml/languages/toml/brackets.scm b/extensions/toml/languages/toml/brackets.scm
deleted file mode 100644
index 9e8c9cd93c30f7697ead2161295b4583ffdfb93b..0000000000000000000000000000000000000000
--- a/extensions/toml/languages/toml/brackets.scm
+++ /dev/null
@@ -1,3 +0,0 @@
-("[" @open "]" @close)
-("{" @open "}" @close)
-("\"" @open "\"" @close)
diff --git a/extensions/toml/languages/toml/config.toml b/extensions/toml/languages/toml/config.toml
deleted file mode 100644
index f62290d9e9244603eaa22dc98297f84f694635e4..0000000000000000000000000000000000000000
--- a/extensions/toml/languages/toml/config.toml
+++ /dev/null
@@ -1,11 +0,0 @@
-name = "TOML"
-grammar = "toml"
-path_suffixes = ["Cargo.lock", "toml", "Pipfile", "uv.lock"]
-line_comments = ["# "]
-autoclose_before = ",]}"
-brackets = [
-    { start = "{", end = "}", close = true, newline = true },
-    { start = "[", end = "]", close = true, newline = true },
-    { start = "\"", end = "\"", close = true, newline = false, not_in = ["comment", "string"] },
-    { start = "'", end = "'", close = true, newline = false, not_in = ["comment", "string"] },
-]
diff --git a/extensions/toml/languages/toml/highlights.scm b/extensions/toml/languages/toml/highlights.scm
deleted file mode 100644
index 4be265cce74b3d8916e96f428550ea405db915e0..0000000000000000000000000000000000000000
--- a/extensions/toml/languages/toml/highlights.scm
+++ /dev/null
@@ -1,38 +0,0 @@
-; Properties
-;-----------
-
-(bare_key) @property
-(quoted_key) @property
-
-; Literals
-;---------
-
-(boolean) @constant
-(comment) @comment
-(integer) @number
-(float) @number
-(string) @string
-(escape_sequence) @string.escape
-(offset_date_time) @string.special
-(local_date_time) @string.special
-(local_date) @string.special
-(local_time) @string.special
-
-; Punctuation
-;------------
-
-[
-  "."
-  ","
-] @punctuation.delimiter
-
-"=" @operator
-
-[
-  "["
-  "]"
-  "[["
-  "]]"
-  "{"
-  "}"
-]  @punctuation.bracket
diff --git a/extensions/toml/languages/toml/indents.scm b/extensions/toml/languages/toml/indents.scm
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/extensions/toml/languages/toml/outline.scm b/extensions/toml/languages/toml/outline.scm
deleted file mode 100644
index 0b3794962835a6c993e212aef5607bc859196fe9..0000000000000000000000000000000000000000
--- a/extensions/toml/languages/toml/outline.scm
+++ /dev/null
@@ -1,15 +0,0 @@
-(table
-  .
-  "["
-  .
-  (_) @name) @item
-
-(table_array_element
-  .
-  "[["
-  .
-  (_) @name) @item
-
-(pair
-  .
-  (_) @name) @item
diff --git a/extensions/toml/languages/toml/overrides.scm b/extensions/toml/languages/toml/overrides.scm
deleted file mode 100644
index 81fec9a5f57b28fc67b4781ec37df43559e21dc9..0000000000000000000000000000000000000000
--- a/extensions/toml/languages/toml/overrides.scm
+++ /dev/null
@@ -1,2 +0,0 @@
-(comment) @comment.inclusive
-(string) @string
diff --git a/extensions/toml/languages/toml/redactions.scm b/extensions/toml/languages/toml/redactions.scm
deleted file mode 100644
index a906e9ac7b3e6561937ec7642e851a71fa2e3fec..0000000000000000000000000000000000000000
--- a/extensions/toml/languages/toml/redactions.scm
+++ /dev/null
@@ -1 +0,0 @@
-(pair (bare_key) "=" (_) @redact)
diff --git a/extensions/toml/languages/toml/textobjects.scm b/extensions/toml/languages/toml/textobjects.scm
deleted file mode 100644
index f5b4856e27a76a90d577f54fdd6104ec6bce795f..0000000000000000000000000000000000000000
--- a/extensions/toml/languages/toml/textobjects.scm
+++ /dev/null
@@ -1,6 +0,0 @@
-(comment)+ @comment
-(table "[" (_) "]"
-    (_)* @class.inside) @class.around
-
-(table_array_element "[[" (_) "]]"
-    (_)* @class.inside) @class.around
diff --git a/extensions/toml/src/toml.rs b/extensions/toml/src/toml.rs
deleted file mode 100644
index c9b96aecacd17d192fad9b6801973c2f2389cf98..0000000000000000000000000000000000000000
--- a/extensions/toml/src/toml.rs
+++ /dev/null
@@ -1,152 +0,0 @@
-use std::fs;
-use zed::LanguageServerId;
-use zed_extension_api::settings::LspSettings;
-use zed_extension_api::{self as zed, Result};
-
-struct TaploBinary {
-    path: String,
-    args: Option<Vec<String>>,
-}
-
-struct TomlExtension {
-    cached_binary_path: Option<String>,
-}
-
-impl TomlExtension {
-    fn language_server_binary(
-        &mut self,
-        language_server_id: &LanguageServerId,
-        worktree: &zed::Worktree,
-    ) -> Result<TaploBinary> {
-        let binary_settings = LspSettings::for_worktree("taplo", worktree)
-            .ok()
-            .and_then(|lsp_settings| lsp_settings.binary);
-        let binary_args = binary_settings
-            .as_ref()
-            .and_then(|binary_settings| binary_settings.arguments.clone());
-
-        if let Some(path) = binary_settings.and_then(|binary_settings| binary_settings.path) {
-            return Ok(TaploBinary {
-                path,
-                args: binary_args,
-            });
-        }
-
-        if let Some(path) = worktree.which("taplo") {
-            return Ok(TaploBinary {
-                path,
-                args: binary_args,
-            });
-        }
-
-        if let Some(path) = &self.cached_binary_path
-            && fs::metadata(path).is_ok_and(|stat| stat.is_file())
-        {
-            return Ok(TaploBinary {
-                path: path.clone(),
-                args: binary_args,
-            });
-        }
-
-        zed::set_language_server_installation_status(
-            language_server_id,
-            &zed::LanguageServerInstallationStatus::CheckingForUpdate,
-        );
-        let release = zed::latest_github_release(
-            "tamasfe/taplo",
-            zed::GithubReleaseOptions {
-                require_assets: true,
-                pre_release: false,
-            },
-        )?;
-
-        let (platform, arch) = zed::current_platform();
-        let asset_name = format!(
-            "taplo-{os}-{arch}.gz",
-            arch = match arch {
-                zed::Architecture::Aarch64 => "aarch64",
-                zed::Architecture::X86 => "x86",
-                zed::Architecture::X8664 => "x86_64",
-            },
-            os = match platform {
-                zed::Os::Mac => "darwin",
-                zed::Os::Linux => "linux",
-                zed::Os::Windows => "windows",
-            },
-        );
-
-        let asset = release
-            .assets
-            .iter()
-            .find(|asset| asset.name == asset_name)
-            .ok_or_else(|| format!("no asset found matching {:?}", asset_name))?;
-
-        let version_dir = format!("taplo-{}", release.version);
-        fs::create_dir_all(&version_dir)
-            .map_err(|err| format!("failed to create directory '{version_dir}': {err}"))?;
-
-        let binary_path = format!(
-            "{version_dir}/{bin_name}",
-            bin_name = match platform {
-                zed::Os::Windows => "taplo.exe",
-                zed::Os::Mac | zed::Os::Linux => "taplo",
-            }
-        );
-
-        if !fs::metadata(&binary_path).is_ok_and(|stat| stat.is_file()) {
-            zed::set_language_server_installation_status(
-                language_server_id,
-                &zed::LanguageServerInstallationStatus::Downloading,
-            );
-
-            zed::download_file(
-                &asset.download_url,
-                &binary_path,
-                zed::DownloadedFileType::Gzip,
-            )
-            .map_err(|err| format!("failed to download file: {err}"))?;
-
-            zed::make_file_executable(&binary_path)?;
-
-            let entries = fs::read_dir(".")
-                .map_err(|err| format!("failed to list working directory {err}"))?;
-            for entry in entries {
-                let entry = entry.map_err(|err| format!("failed to load directory entry {err}"))?;
-                if entry.file_name().to_str() != Some(&version_dir) {
-                    fs::remove_dir_all(entry.path()).ok();
-                }
-            }
-        }
-
-        self.cached_binary_path = Some(binary_path.clone());
-        Ok(TaploBinary {
-            path: binary_path,
-            args: binary_args,
-        })
-    }
-}
-
-impl zed::Extension for TomlExtension {
-    fn new() -> Self {
-        Self {
-            cached_binary_path: None,
-        }
-    }
-
-    fn language_server_command(
-        &mut self,
-        language_server_id: &LanguageServerId,
-        worktree: &zed::Worktree,
-    ) -> Result<zed::Command> {
-        let taplo_binary = self.language_server_binary(language_server_id, worktree)?;
-        Ok(zed::Command {
-            command: taplo_binary.path,
-            args: taplo_binary
-                .args
-                .unwrap_or_else(|| vec!["lsp".to_string(), "stdio".to_string()]),
-            env: Default::default(),
-        })
-    }
-}
-
-zed::register_extension!(TomlExtension);
diff --git a/script/bundle-windows.ps1 b/script/bundle-windows.ps1
index 84ad39fb706f9d3e0e4af73a68b468e0bea33ee1..a26abf8413f375b611d01d57b61ac3f91a960dd7 100644
--- a/script/bundle-windows.ps1
+++ b/script/bundle-windows.ps1
@@ -150,7 +150,7 @@ function CollectFiles {
     Move-Item -Path "$innoDir\zed_explorer_command_injector.appx" -Destination "$innoDir\appx\zed_explorer_command_injector.appx" -Force
     Move-Item -Path "$innoDir\zed_explorer_command_injector.dll" -Destination "$innoDir\appx\zed_explorer_command_injector.dll" -Force
     Move-Item -Path "$innoDir\cli.exe" -Destination "$innoDir\bin\zed.exe" -Force
-    Move-Item -Path "$innoDir\zed-wsl" -Destination "$innoDir\bin\zed" -Force
+    Move-Item -Path "$innoDir\zed.sh" -Destination "$innoDir\bin\zed" -Force
     Move-Item -Path "$innoDir\auto_update_helper.exe" -Destination "$innoDir\tools\auto_update_helper.exe" -Force
     Move-Item -Path ".\AGS_SDK-6.3.0\ags_lib\lib\amd_ags_x64.dll" -Destination "$innoDir\amd_ags_x64.dll" -Force
 }
diff --git a/script/linux b/script/linux
index 029278bea383b50b949a42a3e1af518a4366f732..47f58c0bc5ff9e8127f51251c8e0420fc08debba 100755
--- a/script/linux
+++ b/script/linux
@@ -47,7 +47,10 @@ if [[ -n $apt ]]; then
     musl-dev
     build-essential
   )
-  if (grep -qP 'PRETTY_NAME="(Linux Mint 22|.+24\.(04|10))' /etc/os-release); then
+  if (grep -qP 'PRETTY_NAME="((Debian|Raspbian).+13|' /etc/os-release); then
+      # libstdc++-14-dev is in build-essential
+      deps+=( mold )
+  elif (grep -qP 'PRETTY_NAME="(Linux Mint 22|.+24\.(04|10))' /etc/os-release); then
     deps+=( mold libstdc++-14-dev )
   elif (grep -qP 'PRETTY_NAME="((Debian|Raspbian).+12|Linux Mint 21|.+22\.04)' /etc/os-release); then
     deps+=( mold libstdc++-12-dev )