Merge remote-tracking branch 'origin/main' into anthropic_base_url

agent_ui: Fix crash when typing multibyte character after mention (#37847 )
Closes #36333 Release Notes: - Fixed a crash that occurred when typing an IME character right after a mention in the Agent Panel.
2025-09-09 10:31:34 -04:00 · 2025-09-09 19:16:22 +05:30 · 2025-09-09 09:36:12 -03:00 · 2025-09-09 11:21:51 +00:00 · 2025-09-09 13:46:59 +03:00 · 2025-09-09 08:04:27 +00:00
423 changed files with 15536 additions and 16341 deletions
--- 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]
--- a/.config/hakari.toml
+++ b/.config/hakari.toml
@@ -41,5 +41,4 @@ workspace-members = [
    "slash_commands_example",
    "zed_snippets",
    "zed_test_extension",
-    "zed_toml",
 ]
--- 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
--- 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

--- 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:

--- 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",
--- 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"
--- 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": {
--- 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,
--- 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",
--- 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"
    }
  },
--- 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"
    }
  },
--- 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": {
--- 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,
--- 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>()
--- 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);
            }
        }
--- a/crates/activity_indicator/src/activity_indicator.rs
+++ b/crates/activity_indicator/src/activity_indicator.rs
@@ -84,7 +84,6 @@ impl ActivityIndicator {
    ) -> Entity<ActivityIndicator> {
        let project = workspace.project().clone();
        let auto_updater = AutoUpdater::get(cx);
-        let workspace_handle = cx.entity();
        let this = cx.new(|cx| {
            let mut status_events = languages.language_server_binary_statuses();
            cx.spawn(async move |this, cx| {
@@ -102,20 +101,6 @@ impl ActivityIndicator {
            })
            .detach();

-            cx.subscribe_in(
-                &workspace_handle,
-                window,
-                |activity_indicator, _, event, window, cx| {
-                    if let workspace::Event::ClearActivityIndicator = event
-                        && activity_indicator.statuses.pop().is_some()
-                    {
-                        activity_indicator.dismiss_error_message(&DismissErrorMessage, window, cx);
-                        cx.notify();
-                    }
-                },
-            )
-            .detach();
-
            cx.subscribe(
                &project.read(cx).lsp_store(),
                |activity_indicator, _, event, cx| {
@@ -227,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| {
--- 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,
+            ))
        })
    }

--- 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()
    }

--- 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> {
--- 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?;
--- 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);
--- 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 {
--- 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 {
--- 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,
--- a/crates/agent2/src/tools/edit_file_tool.rs
+++ b/crates/agent2/src/tools/edit_file_tool.rs
@@ -83,6 +83,7 @@ struct EditFileToolPartialInput {

 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "lowercase")]
+#[schemars(inline)]
 pub enum EditFileMode {
    Edit,
    Create,
@@ -119,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,
        }
@@ -194,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()
@@ -544,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(),
@@ -559,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!(
@@ -742,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(),
@@ -774,6 +810,7 @@ mod tests {
                    mode: EditFileMode::Overwrite,
                };
                Arc::new(EditFileTool::new(
+                    project.clone(),
                    thread.downgrade(),
                    language_registry.clone(),
                ))
@@ -832,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
@@ -884,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(),
@@ -917,6 +955,7 @@ mod tests {
                    mode: EditFileMode::Overwrite,
                };
                Arc::new(EditFileTool::new(
+                    project.clone(),
                    thread.downgrade(),
                    language_registry.clone(),
                ))
@@ -968,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
@@ -1011,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(),
@@ -1019,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
@@ -1147,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(),
@@ -1155,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![
@@ -1263,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![
@@ -1343,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![
@@ -1426,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![
@@ -1506,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]
@@ -1574,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(
@@ -1599,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(
@@ -1622,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(
--- 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(),
--- 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));
--- 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();
--- 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()
--- 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);
--- a/crates/agent2/src/tools/now_tool.rs
+++ b/crates/agent2/src/tools/now_tool.rs
@@ -11,6 +11,7 @@ use crate::{AgentTool, ToolCallEventStream};

 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
+#[schemars(inline)]
 pub enum Timezone {
    /// Use UTC for the datetime.
    Utc,
@@ -40,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()
    }

--- 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?;

--- 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()
-                        })
-                    }
+                    })
                }
            })?;

--- 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?;

--- 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()
    }

--- 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()
    }

--- 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]
--- 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
--- 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
-}
--- 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,53 +32,42 @@ 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| {
+            if let Some(path) = project.active_project_directory(cx) {
+                Some(project.directory_environment(path, cx))
+            } else {
+                None
+            }
        });

        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?
-            };
-
-            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))
        })
    }

--- 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,14 +32,36 @@ impl crate::AgentServer for CustomAgentServer {

    fn connect(
        &self,
-        root_dir: &Path,
-        _delegate: AgentServerDelegate,
+        root_dir: Option<&Path>,
+        delegate: AgentServerDelegate,
        cx: &mut App,
-    ) -> Task<Result<Rc<dyn AgentConnection>>> {
-        let server_name = self.name();
-        let command = self.command.clone();
-        let root_dir = root_dir.to_path_buf();
-        cx.spawn(async move |cx| crate::acp::connect(server_name, command, &root_dir, cx).await)
+    ) -> 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| {
+            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))
+        })
    }

    fn into_any(self: Rc<Self>) -> Rc<dyn std::any::Any> {
--- 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();

--- 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,120 +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()
+    ) -> 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());
-            }
-
+            let mut extra_env = HashMap::default();
            if let Some(api_key) = cx.update(GoogleLanguageModelProvider::api_key)?.await.ok() {
-                command
-                    .env
-                    .get_or_insert_default()
-                    .insert("GEMINI_API_KEY".to_owned(), api_key.key);
+                extra_env.insert("GEMINI_API_KEY".into(), api_key.key);
+            }
+            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());
            }

-            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))
        })
    }

@@ -153,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");
--- a/crates/agent_servers/src/settings.rs
+++ b/crates/agent_servers/src/settings.rs
@@ -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) {}
-}
--- 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;
--- 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"
+        );
    }
 }
--- 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 { .. } => {}
--- 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
--- 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(
--- 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(),
                )
--- 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> {
--- 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()));
--- 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,
                )
--- 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
--- 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()
--- 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>()]);
        }
    });
 }
--- 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;
--- 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 => {
--- 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,
--- 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)
--- 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);
--- 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")
--- 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> {
--- 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"))
--- 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",
--- 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
--- 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)
--- 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
--- 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(
--- 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) {
--- 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());
--- 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());
--- 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());
--- 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 {
--- 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());
--- 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> {
--- 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> {
--- 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?;
--- 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 {
--- 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> {
--- 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
--- 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());
 }
--- a/crates/channel/src/channel_chat.rs
+++ b/crates/channel/src/channel_chat.rs
@@ -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,
-        }
-    }
-}
--- 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);
--- 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);
--- 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"
--- 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 {
--- 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"))]
    {
--- 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]
--- 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 {}
 }
--- 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)]
--- 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;
--- 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,
        })
    }

--- a/crates/collab/src/db/queries/messages.rs
+++ b/crates/collab/src/db/queries/messages.rs
@@ -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
-    }
-}
--- 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
--- 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,
-    }
-}
--- 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
--- a/crates/collab/src/db/tests/message_tests.rs
+++ b/crates/collab/src/db/tests/message_tests.rs
@@ -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())]),
-            ),
-        ]
-    );
-}
--- 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
--- a/Show More
+++ b/Show More