make it remove old paths

Write to the user settings file when changing language with the selector
2025-09-03 21:55:09 -07:00 · 2025-09-03 21:43:47 -07:00
448 changed files with 17520 additions and 16244 deletions
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -19,6 +19,8 @@ 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,4 +41,5 @@ 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.sh text eol=lf
+crates/zed/resources/windows/zed-wsl text eol=lf
--- a/.rules
+++ b/.rules
@@ -12,19 +12,6 @@
  - 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.9.1",
+ "rand 0.8.5",
 "serde",
 "serde_json",
 "settings",
@@ -79,7 +79,7 @@ dependencies = [
 "log",
 "pretty_assertions",
 "project",
- "rand 0.9.1",
+ "rand 0.8.5",
 "serde_json",
 "settings",
 "text",
@@ -172,7 +172,7 @@ dependencies = [
 "pretty_assertions",
 "project",
 "prompt_store",
- "rand 0.9.1",
+ "rand 0.8.5",
 "ref-cast",
 "rope",
 "schemars",
@@ -308,18 +308,22 @@ 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",
 ]

@@ -404,7 +408,7 @@ dependencies = [
 "project",
 "prompt_store",
 "proto",
- "rand 0.9.1",
+ "rand 0.8.5",
 "release_channel",
 "rope",
 "rules_library",
@@ -482,7 +486,6 @@ dependencies = [
 "client",
 "cloud_llm_client",
 "component",
- "feature_flags",
 "gpui",
 "language_model",
 "serde",
@@ -831,7 +834,7 @@ dependencies = [
 "project",
 "prompt_store",
 "proto",
- "rand 0.9.1",
+ "rand 0.8.5",
 "regex",
 "rpc",
 "serde",
@@ -930,7 +933,7 @@ dependencies = [
 "parking_lot",
 "pretty_assertions",
 "project",
- "rand 0.9.1",
+ "rand 0.8.5",
 "regex",
 "serde",
 "serde_json",
@@ -982,7 +985,7 @@ dependencies = [
 "pretty_assertions",
 "project",
 "prompt_store",
- "rand 0.9.1",
+ "rand 0.8.5",
 "regex",
 "reqwest_client",
 "rust-embed",
@@ -2288,7 +2291,7 @@ dependencies = [
 [[package]]
 name = "blade-graphics"
 version = "0.6.0"
-source = "git+https://github.com/kvark/blade?rev=bfa594ea697d4b6326ea29f747525c85ecf933b9#bfa594ea697d4b6326ea29f747525c85ecf933b9"
+source = "git+https://github.com/kvark/blade?rev=e0ec4e720957edd51b945b64dd85605ea54bcfe5#e0ec4e720957edd51b945b64dd85605ea54bcfe5"
 dependencies = [
 "ash",
 "ash-window",
@@ -2321,7 +2324,7 @@ dependencies = [
 [[package]]
 name = "blade-macros"
 version = "0.3.0"
-source = "git+https://github.com/kvark/blade?rev=bfa594ea697d4b6326ea29f747525c85ecf933b9#bfa594ea697d4b6326ea29f747525c85ecf933b9"
+source = "git+https://github.com/kvark/blade?rev=e0ec4e720957edd51b945b64dd85605ea54bcfe5#e0ec4e720957edd51b945b64dd85605ea54bcfe5"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2331,7 +2334,7 @@ dependencies = [
 [[package]]
 name = "blade-util"
 version = "0.2.0"
-source = "git+https://github.com/kvark/blade?rev=bfa594ea697d4b6326ea29f747525c85ecf933b9#bfa594ea697d4b6326ea29f747525c85ecf933b9"
+source = "git+https://github.com/kvark/blade?rev=e0ec4e720957edd51b945b64dd85605ea54bcfe5#e0ec4e720957edd51b945b64dd85605ea54bcfe5"
 dependencies = [
 "blade-graphics",
 "bytemuck",
@@ -2348,6 +2351,19 @@ 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"
@@ -2462,7 +2478,7 @@ dependencies = [
 "language",
 "log",
 "pretty_assertions",
- "rand 0.9.1",
+ "rand 0.8.5",
 "rope",
 "serde_json",
 "sum_tree",
@@ -2883,9 +2899,11 @@ dependencies = [
 "language",
 "log",
 "postage",
+ "rand 0.8.5",
 "release_channel",
 "rpc",
 "settings",
+ "sum_tree",
 "text",
 "time",
 "util",
@@ -3052,6 +3070,7 @@ dependencies = [
 "clock",
 "cloud_api_client",
 "cloud_llm_client",
+ "cocoa 0.26.0",
 "collections",
 "credentials_provider",
 "derive_more",
@@ -3064,11 +3083,10 @@ dependencies = [
 "http_client_tls",
 "httparse",
 "log",
- "objc2-foundation",
 "parking_lot",
 "paths",
 "postage",
- "rand 0.9.1",
+ "rand 0.8.5",
 "regex",
 "release_channel",
 "rpc",
@@ -3317,7 +3335,7 @@ dependencies = [
 "prometheus",
 "prompt_store",
 "prost 0.9.0",
- "rand 0.9.1",
+ "rand 0.8.5",
 "recent_projects",
 "release_channel",
 "remote",
@@ -3373,10 +3391,12 @@ dependencies = [
 "collections",
 "db",
 "editor",
+ "emojis",
 "futures 0.3.31",
 "fuzzy",
 "gpui",
 "http_client",
+ "language",
 "log",
 "menu",
 "notifications",
@@ -3384,6 +3404,7 @@ dependencies = [
 "pretty_assertions",
 "project",
 "release_channel",
+ "rich_text",
 "rpc",
 "schemars",
 "serde",
@@ -3494,7 +3515,6 @@ name = "component"
 version = "0.1.0"
 dependencies = [
 "collections",
- "documented",
 "gpui",
 "inventory",
 "parking_lot",
@@ -3557,6 +3577,12 @@ 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"
@@ -4671,7 +4697,7 @@ dependencies = [
 "markdown",
 "pretty_assertions",
 "project",
- "rand 0.9.1",
+ "rand 0.8.5",
 "serde",
 "serde_json",
 "settings",
@@ -5042,7 +5068,7 @@ dependencies = [
 "parking_lot",
 "pretty_assertions",
 "project",
- "rand 0.9.1",
+ "rand 0.8.5",
 "regex",
 "release_channel",
 "rpc",
@@ -5537,7 +5563,7 @@ dependencies = [
 "parking_lot",
 "paths",
 "project",
- "rand 0.9.1",
+ "rand 0.8.5",
 "release_channel",
 "remote",
 "reqwest_client",
@@ -6137,6 +6163,17 @@ 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"
@@ -6232,6 +6269,12 @@ 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"
@@ -6369,7 +6412,7 @@ dependencies = [
 "log",
 "parking_lot",
 "pretty_assertions",
- "rand 0.9.1",
+ "rand 0.8.5",
 "regex",
 "rope",
 "schemars",
@@ -7382,7 +7425,6 @@ dependencies = [
 "calloop",
 "calloop-wayland-source",
 "cbindgen",
- "chrono",
 "cocoa 0.26.0",
 "collections",
 "core-foundation 0.10.0",
@@ -7423,13 +7465,12 @@ dependencies = [
 "pathfinder_geometry",
 "postage",
 "profiling",
- "rand 0.9.1",
+ "rand 0.8.5",
 "raw-window-handle",
 "refineable",
 "reqwest_client",
 "resvg",
 "scap",
- "scheduler",
 "schemars",
 "seahash",
 "semantic_version",
@@ -9037,7 +9078,7 @@ dependencies = [
 "parking_lot",
 "postage",
 "pretty_assertions",
- "rand 0.9.1",
+ "rand 0.8.5",
 "regex",
 "rpc",
 "schemars",
@@ -9179,19 +9220,6 @@ 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"
@@ -9219,7 +9247,6 @@ dependencies = [
 "anyhow",
 "client",
 "collections",
- "command_palette_hooks",
 "copilot",
 "editor",
 "futures 0.3.31",
@@ -9254,6 +9281,7 @@ dependencies = [
 "chrono",
 "collections",
 "dap",
+ "feature_flags",
 "futures 0.3.31",
 "gpui",
 "http_client",
@@ -9489,21 +9517,6 @@ 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"
@@ -10379,7 +10392,7 @@ dependencies = [
 "parking_lot",
 "pretty_assertions",
 "project",
- "rand 0.9.1",
+ "rand 0.8.5",
 "rope",
 "serde",
 "settings",
@@ -12605,13 +12618,12 @@ dependencies = [
 "postage",
 "prettier",
 "pretty_assertions",
- "rand 0.9.1",
+ "rand 0.8.5",
 "regex",
 "release_channel",
 "remote",
 "rpc",
 "schemars",
- "semver",
 "serde",
 "serde_json",
 "settings",
@@ -12631,7 +12643,6 @@ dependencies = [
 "unindent",
 "url",
 "util",
- "watch",
 "which 6.0.3",
 "workspace-hack",
 "worktree",
@@ -13552,7 +13563,6 @@ dependencies = [
 "alacritty_terminal",
 "anyhow",
 "async-dispatcher",
- "async-task",
 "async-tungstenite",
 "base64 0.22.1",
 "client",
@@ -13882,7 +13892,7 @@ dependencies = [
 "ctor",
 "gpui",
 "log",
- "rand 0.9.1",
+ "rand 0.8.5",
 "rayon",
 "smallvec",
 "sum_tree",
@@ -13911,7 +13921,7 @@ dependencies = [
 "gpui",
 "parking_lot",
 "proto",
- "rand 0.9.1",
+ "rand 0.8.5",
 "rsa",
 "serde",
 "serde_json",
@@ -14346,19 +14356,6 @@ dependencies = [
 "windows-sys 0.59.0",
 ]

-[[package]]
-name = "scheduler"
-version = "0.1.0"
-dependencies = [
- "async-task",
- "backtrace",
- "chrono",
- "futures 0.3.31",
- "parking_lot",
- "rand 0.9.1",
- "workspace-hack",
-]
-
 [[package]]
 name = "schema_generator"
 version = "0.1.0"
@@ -14661,6 +14658,49 @@ 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"
@@ -15278,7 +15318,6 @@ dependencies = [
 "futures 0.3.31",
 "indoc",
 "libsqlite3-sys",
- "log",
 "parking_lot",
 "smol",
 "sqlformat",
@@ -15616,7 +15655,7 @@ name = "streaming_diff"
 version = "0.1.0"
 dependencies = [
 "ordered-float 2.10.1",
- "rand 0.9.1",
+ "rand 0.8.5",
 "rope",
 "util",
 "workspace-hack",
@@ -15730,7 +15769,7 @@ dependencies = [
 "arrayvec",
 "ctor",
 "log",
- "rand 0.9.1",
+ "rand 0.8.5",
 "rayon",
 "workspace-hack",
 "zlog",
@@ -16321,7 +16360,7 @@ dependencies = [
 "futures 0.3.31",
 "gpui",
 "libc",
- "rand 0.9.1",
+ "rand 0.8.5",
 "regex",
 "release_channel",
 "schemars",
@@ -16369,7 +16408,7 @@ dependencies = [
 "language",
 "log",
 "project",
- "rand 0.9.1",
+ "rand 0.8.5",
 "regex",
 "schemars",
 "search",
@@ -16401,7 +16440,7 @@ dependencies = [
 "log",
 "parking_lot",
 "postage",
- "rand 0.9.1",
+ "rand 0.8.5",
 "regex",
 "rope",
 "smallvec",
@@ -16932,15 +16971,10 @@ 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",
@@ -17763,7 +17797,7 @@ dependencies = [
 "libc",
 "log",
 "nix 0.29.0",
- "rand 0.9.1",
+ "rand 0.8.5",
 "regex",
 "rust-embed",
 "schemars",
@@ -17948,8 +17982,6 @@ version = "0.1.0"
 dependencies = [
 "anyhow",
 "gpui",
- "schemars",
- "serde",
 "settings",
 "workspace-hack",
 ]
@@ -18556,7 +18588,7 @@ dependencies = [
 "futures 0.3.31",
 "gpui",
 "parking_lot",
- "rand 0.9.1",
+ "rand 0.8.5",
 "workspace-hack",
 "zlog",
 ]
@@ -20015,7 +20047,7 @@ dependencies = [
 "paths",
 "postage",
 "pretty_assertions",
- "rand 0.9.1",
+ "rand 0.8.5",
 "rpc",
 "schemars",
 "serde",
@@ -20376,6 +20408,7 @@ dependencies = [
 "acp_tools",
 "activity_indicator",
 "agent",
+ "agent_servers",
 "agent_settings",
 "agent_ui",
 "anyhow",
@@ -20439,12 +20472,10 @@ dependencies = [
 "language_extension",
 "language_model",
 "language_models",
- "language_onboarding",
 "language_selector",
 "language_tools",
 "languages",
 "libc",
- "line_ending_selector",
 "livekit_client",
 "log",
 "markdown",
@@ -20596,7 +20627,7 @@ dependencies = [

 [[package]]
 name = "zed_snippets"
-version = "0.0.6"
+version = "0.0.5"
 dependencies = [
 "serde_json",
 "zed_extension_api 0.1.0",
@@ -20609,6 +20640,13 @@ 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"
@@ -20772,10 +20810,9 @@ dependencies = [
 "language_model",
 "log",
 "menu",
- "parking_lot",
 "postage",
 "project",
- "rand 0.9.1",
+ "rand 0.8.5",
 "regex",
 "release_channel",
 "reqwest_client",
@@ -20845,7 +20882,7 @@ dependencies = [
 "aes",
 "byteorder",
 "bzip2",
- "constant_time_eq",
+ "constant_time_eq 0.1.5",
 "crc32fast",
 "crossbeam-utils",
 "flate2",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -94,11 +94,9 @@ 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",
@@ -133,7 +131,6 @@ members = [
    "crates/refineable",
    "crates/refineable/derive_refineable",
    "crates/release_channel",
-    "crates/scheduler",
    "crates/remote",
    "crates/remote_server",
    "crates/repl",
@@ -144,6 +141,7 @@ members = [
    "crates/rules_library",
    "crates/schema_generator",
    "crates/search",
+    "crates/semantic_index",
    "crates/semantic_version",
    "crates/session",
    "crates/settings",
@@ -212,6 +210,7 @@ members = [
    "extensions/slash-commands-example",
    "extensions/snippets",
    "extensions/test-extension",
+    "extensions/toml",

    #
    # Tooling
@@ -321,11 +320,9 @@ 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" }
@@ -363,7 +360,6 @@ 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" }
@@ -374,6 +370,7 @@ 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" }
@@ -447,7 +444,6 @@ 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"] }
@@ -460,13 +456,12 @@ aws-sdk-bedrockruntime = { version = "1.80.0", features = [
 ] }
 aws-smithy-runtime-api = { version = "1.7.4", features = ["http-1x", "client"] }
 aws-smithy-types = { version = "1.3.0", features = ["http-body-1-x"] }
-backtrace = "0.3"
 base64 = "0.22"
 bincode = "1.2.1"
 bitflags = "2.6.0"
-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" }
+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" }
 blake3 = "1.5.3"
 bytes = "1.0"
 cargo_metadata = "0.19"
@@ -540,31 +535,6 @@ 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"] }
@@ -590,7 +560,7 @@ prost-build = "0.9"
 prost-types = "0.9"
 pulldown-cmark = { version = "0.12.0", default-features = false }
 quote = "1.0.9"
-rand = "0.9"
+rand = "0.8.5"
 rayon = "1.8"
 ref-cast = "1.0.24"
 regex = "1.5"
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -16,7 +16,6 @@
      "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",
@@ -583,7 +582,7 @@
      "ctrl-n": "workspace::NewFile",
      "shift-new": "workspace::NewWindow",
      "ctrl-shift-n": "workspace::NewWindow",
-      "ctrl-`": "terminal_panel::Toggle",
+      "ctrl-`": "terminal_panel::ToggleFocus",
      "f10": ["app_menu::OpenApplicationMenu", "Zed"],
      "alt-1": ["workspace::ActivatePane", 0],
      "alt-2": ["workspace::ActivatePane", 1],
@@ -628,7 +627,6 @@
      "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",
@@ -1029,13 +1027,6 @@
      "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::Toggle",
+      "ctrl-`": "terminal_panel::ToggleFocus",
      "cmd-1": ["workspace::ActivatePane", 0],
      "cmd-2": ["workspace::ActivatePane", 1],
      "cmd-3": ["workspace::ActivatePane", 2],
@@ -690,7 +690,6 @@
      "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",
@@ -1095,13 +1094,6 @@
      "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,6 +25,7 @@
      "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 }],
@@ -67,13 +68,18 @@
      "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",
@@ -132,6 +138,7 @@
      "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",
@@ -170,6 +177,7 @@
    "context": "Markdown",
    "use_key_equivalents": true,
    "bindings": {
+      "copy": "markdown::Copy",
      "ctrl-c": "markdown::Copy"
    }
  },
@@ -217,6 +225,7 @@
    "bindings": {
      "ctrl-enter": "assistant::Assist",
      "ctrl-s": "workspace::Save",
+      "save": "workspace::Save",
      "ctrl-shift-,": "assistant::InsertIntoEditor",
      "shift-enter": "assistant::Split",
      "ctrl-r": "assistant::CycleMessageRole",
@@ -263,6 +272,7 @@
    "context": "AgentPanel > Markdown",
    "use_key_equivalents": true,
    "bindings": {
+      "copy": "markdown::CopyAsMarkdown",
      "ctrl-c": "markdown::CopyAsMarkdown"
    }
  },
@@ -357,6 +367,7 @@
    "context": "PromptLibrary",
    "use_key_equivalents": true,
    "bindings": {
+      "new": "rules_library::NewRule",
      "ctrl-n": "rules_library::NewRule",
      "ctrl-shift-s": "rules_library::ToggleDefaultRule"
    }
@@ -370,6 +381,7 @@
      "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"
@@ -396,6 +408,7 @@
    "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
@@ -459,12 +472,14 @@
      "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",
@@ -564,21 +579,27 @@
    "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::Toggle",
+      "ctrl-`": "terminal_panel::ToggleFocus",
      "f10": ["app_menu::OpenApplicationMenu", "Zed"],
      "alt-1": ["workspace::ActivatePane", 0],
      "alt-2": ["workspace::ActivatePane", 1],
@@ -600,6 +621,7 @@
      "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",
@@ -619,9 +641,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",
@@ -826,7 +848,9 @@
    "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",
@@ -842,14 +866,21 @@
    "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",
@@ -861,6 +892,7 @@
      "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",
@@ -1043,13 +1075,6 @@
      "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,
@@ -1085,8 +1110,10 @@
    "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",
@@ -1102,6 +1129,7 @@
      "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",
@@ -1182,6 +1210,7 @@
    "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::Toggle",
+      "alt-f12": "terminal_panel::ToggleFocus",
      "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::Toggle",
+      "alt-f12": "terminal_panel::ToggleFocus",
      "cmd-shift-k": "git::Push"
    }
  },
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -32,6 +32,34 @@
      "(": "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",
@@ -55,6 +83,10 @@
      "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 }],
@@ -187,46 +219,6 @@
      ".": "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": {
@@ -257,6 +249,9 @@
      "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",
@@ -322,7 +317,10 @@
      "g w": "vim::Rewrap",
      "g ?": "vim::ConvertToRot13",
      // "g ?": "vim::ConvertToRot47",
-      "\"": "vim::PushRegister"
+      "\"": "vim::PushRegister",
+      // tree-sitter related commands
+      "[ x": "editor::SelectLargerSyntaxNode",
+      "] x": "editor::SelectSmallerSyntaxNode"
    }
  },
  {
@@ -399,9 +397,6 @@
      "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",
@@ -424,6 +419,13 @@
      "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",
@@ -467,6 +469,9 @@
      "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",
@@ -535,7 +540,7 @@
    }
  },
  {
-    "context": "vim_operator == a || vim_operator == i || vim_operator == cs || vim_operator == helix_next || vim_operator == helix_previous",
+    "context": "vim_operator == a || vim_operator == i || vim_operator == cs",
    "bindings": {
      "w": "vim::Word",
      "shift-w": ["vim::Word", { "ignore_punctuation": true }],
@@ -572,48 +577,6 @@
      "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,6 +740,16 @@
    // 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,
@@ -952,7 +962,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"]
+    // One of: ["right", "left", "hidden"]
    "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)
    }

-    /// 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 {
+    /// 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 {
            return Task::ready(Err(anyhow!("message not found")));
        };

@@ -1654,30 +1654,15 @@ 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 |_, cx| {
-            rewind.await?;
+        let git_store = self.project.read(cx).git_store().clone();
+        cx.spawn(async move |this, cx| {
            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) {
@@ -1685,11 +1670,7 @@ 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(())
+            })
        })
    }

@@ -1746,6 +1727,20 @@ 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 {
@@ -2119,7 +2114,7 @@ mod tests {
    use gpui::{App, AsyncApp, TestAppContext, WeakEntity};
    use indoc::indoc;
    use project::{FakeFs, Fs};
-    use rand::{distr, prelude::*};
+    use rand::Rng as _;
    use serde_json::json;
    use settings::SettingsStore;
    use smol::stream::StreamExt as _;
@@ -2689,7 +2684,7 @@ mod tests {
                let AgentThreadEntry::UserMessage(message) = &thread.entries[2] else {
                    panic!("unexpected entries {:?}", thread.entries)
                };
-                thread.restore_checkpoint(message.id.clone().unwrap(), cx)
+                thread.rewind(message.id.clone().unwrap(), cx)
            })
            .await
            .unwrap();
@@ -2763,7 +2758,7 @@ mod tests {
        }));

        let thread = cx
-            .update(|cx| connection.new_thread(project, Path::new(path!("/test")), cx))
+            .update(|cx| connection.new_thread(project, Path::new("/test"), cx))
            .await
            .unwrap();

@@ -3062,8 +3057,8 @@ mod tests {
            cx: &mut App,
        ) -> Task<gpui::Result<Entity<AcpThread>>> {
            let session_id = acp::SessionId(
-                rand::rng()
-                    .sample_iter(&distr::Alphanumeric)
+                rand::thread_rng()
+                    .sample_iter(&rand::distributions::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.random_range(0..100) {
+            match rng.gen_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.random_bool(0.5);
+                    let is_agent_edit = rng.gen_bool(0.5);
                    if is_agent_edit {
                        log::info!("agent edit");
                    } else {
@@ -2252,7 +2252,7 @@ mod tests {
                }
            }

-            if rng.random_bool(0.2) {
+            if rng.gen_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,6 +84,7 @@ 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| {
@@ -101,6 +102,20 @@ 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| {
@@ -212,8 +227,7 @@ impl ActivityIndicator {
                server_name,
                status,
            } => {
-                let create_buffer =
-                    project.update(cx, |project, cx| project.create_buffer(false, cx));
+                let create_buffer = project.update(cx, |project, cx| project.create_buffer(cx));
                let status = status.clone();
                let server_name = server_name.clone();
                cx.spawn_in(window, async move |workspace, cx| {
--- a/crates/agent/src/thread.rs
+++ b/crates/agent/src/thread.rs
@@ -1621,7 +1621,7 @@ impl Thread {
            is_input_complete: true,
        };

-        let tool_output = cx.foreground_executor().block_on(tool_result.output);
+        let tool_output = cx.background_executor().block(tool_result.output);

        // Attach a project_notification tool call to the latest existing
        // Assistant message. We cannot create a new Assistant message
--- a/crates/agent2/src/native_agent_server.rs
+++ b/crates/agent2/src/native_agent_server.rs
@@ -35,15 +35,10 @@ impl AgentServer for NativeAgentServer {

    fn connect(
        &self,
-        _root_dir: Option<&Path>,
+        _root_dir: &Path,
        delegate: AgentServerDelegate,
        cx: &mut App,
-    ) -> Task<
-        Result<(
-            Rc<dyn acp_thread::AgentConnection>,
-            Option<task::SpawnInTerminal>,
-        )>,
-    > {
+    ) -> Task<Result<Rc<dyn acp_thread::AgentConnection>>> {
        log::debug!(
            "NativeAgentServer::connect called for path: {:?}",
            _root_dir
@@ -65,10 +60,7 @@ impl AgentServer for NativeAgentServer {
            let connection = NativeAgentConnection(agent);
            log::debug!("NativeAgentServer connection established successfully");

-            Ok((
-                Rc::new(connection) as Rc<dyn acp_thread::AgentConnection>,
-                None,
-            ))
+            Ok(Rc::new(connection) as Rc<dyn acp_thread::AgentConnection>)
        })
    }

--- a/crates/agent2/src/tests/mod.rs
+++ b/crates/agent2/src/tests/mod.rs
@@ -2367,7 +2367,6 @@ async fn setup(cx: &mut TestAppContext, model: TestModel) -> ThreadTest {

        watch_settings(fs.clone(), cx);
    });
-    cx.run_until_parked();

    let templates = Templates::new();

--- a/crates/agent2/src/tests/test_tools.rs
+++ b/crates/agent2/src/tests/test_tools.rs
@@ -24,11 +24,7 @@ impl AgentTool for EchoTool {
        acp::ToolKind::Other
    }

-    fn initial_title(
-        &self,
-        _input: Result<Self::Input, serde_json::Value>,
-        _cx: &mut App,
-    ) -> SharedString {
+    fn initial_title(&self, _input: Result<Self::Input, serde_json::Value>) -> SharedString {
        "Echo".into()
    }

@@ -59,11 +55,7 @@ impl AgentTool for DelayTool {
        "delay"
    }

-    fn initial_title(
-        &self,
-        input: Result<Self::Input, serde_json::Value>,
-        _cx: &mut App,
-    ) -> SharedString {
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
        if let Ok(input) = input {
            format!("Delay {}ms", input.ms).into()
        } else {
@@ -108,11 +100,7 @@ impl AgentTool for ToolRequiringPermission {
        acp::ToolKind::Other
    }

-    fn initial_title(
-        &self,
-        _input: Result<Self::Input, serde_json::Value>,
-        _cx: &mut App,
-    ) -> SharedString {
+    fn initial_title(&self, _input: Result<Self::Input, serde_json::Value>) -> SharedString {
        "This tool requires permission".into()
    }

@@ -147,11 +135,7 @@ impl AgentTool for InfiniteTool {
        acp::ToolKind::Other
    }

-    fn initial_title(
-        &self,
-        _input: Result<Self::Input, serde_json::Value>,
-        _cx: &mut App,
-    ) -> SharedString {
+    fn initial_title(&self, _input: Result<Self::Input, serde_json::Value>) -> SharedString {
        "Infinite Tool".into()
    }

@@ -202,11 +186,7 @@ impl AgentTool for WordListTool {
        acp::ToolKind::Other
    }

-    fn initial_title(
-        &self,
-        _input: Result<Self::Input, serde_json::Value>,
-        _cx: &mut App,
-    ) -> SharedString {
+    fn initial_title(&self, _input: Result<Self::Input, serde_json::Value>) -> 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(), cx);
+        let title = tool.initial_title(tool_use.input.clone());
        let kind = tool.kind();
        stream.send_tool_call(&tool_use.id, title, kind, tool_use.input.clone());

@@ -1062,11 +1062,7 @@ impl Thread {
            self.action_log.clone(),
        ));
        self.add_tool(DiagnosticsTool::new(self.project.clone()));
-        self.add_tool(EditFileTool::new(
-            self.project.clone(),
-            cx.weak_entity(),
-            language_registry,
-        ));
+        self.add_tool(EditFileTool::new(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()));
@@ -1518,7 +1514,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(), cx);
+            title = tool.initial_title(tool_use.input.clone());
            kind = tool.kind();
        }

@@ -2152,11 +2148,7 @@ 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>,
-        cx: &mut App,
-    ) -> SharedString;
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString;

    /// Returns the JSON schema that describes the tool's input.
    fn input_schema(&self, format: LanguageModelToolSchemaFormat) -> Schema {
@@ -2204,7 +2196,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, _cx: &mut App) -> SharedString;
+    fn initial_title(&self, input: serde_json::Value) -> SharedString;
    fn input_schema(&self, format: LanguageModelToolSchemaFormat) -> Result<serde_json::Value>;
    fn supported_provider(&self, _provider: &LanguageModelProviderId) -> bool {
        true
@@ -2240,9 +2232,9 @@ where
        T::kind()
    }

-    fn initial_title(&self, input: serde_json::Value, _cx: &mut App) -> SharedString {
+    fn initial_title(&self, input: serde_json::Value) -> SharedString {
        let parsed_input = serde_json::from_value(input.clone()).map_err(|_| input);
-        self.0.initial_title(parsed_input, _cx)
+        self.0.initial_title(parsed_input)
    }

    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, _cx: &mut App) -> SharedString {
+    fn initial_title(&self, _input: serde_json::Value) -> 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), cx);
+        let authorize = event_stream.authorize(self.initial_title(input.clone()), 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,11 +58,7 @@ impl AgentTool for CopyPathTool {
        ToolKind::Move
    }

-    fn initial_title(
-        &self,
-        input: Result<Self::Input, serde_json::Value>,
-        _cx: &mut App,
-    ) -> ui::SharedString {
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> 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,11 +49,7 @@ impl AgentTool for CreateDirectoryTool {
        ToolKind::Read
    }

-    fn initial_title(
-        &self,
-        input: Result<Self::Input, serde_json::Value>,
-        _cx: &mut App,
-    ) -> SharedString {
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> 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,11 +52,7 @@ impl AgentTool for DeletePathTool {
        ToolKind::Delete
    }

-    fn initial_title(
-        &self,
-        input: Result<Self::Input, serde_json::Value>,
-        _cx: &mut App,
-    ) -> SharedString {
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> 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,11 +71,7 @@ impl AgentTool for DiagnosticsTool {
        acp::ToolKind::Read
    }

-    fn initial_title(
-        &self,
-        input: Result<Self::Input, serde_json::Value>,
-        _cx: &mut App,
-    ) -> SharedString {
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> 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,7 +83,6 @@ struct EditFileToolPartialInput {

 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "lowercase")]
-#[schemars(inline)]
 pub enum EditFileMode {
    Edit,
    Create,
@@ -120,17 +119,11 @@ impl From<EditFileToolOutput> for LanguageModelToolResultContent {
 pub struct EditFileTool {
    thread: WeakEntity<Thread>,
    language_registry: Arc<LanguageRegistry>,
-    project: Entity<Project>,
 }

 impl EditFileTool {
-    pub fn new(
-        project: Entity<Project>,
-        thread: WeakEntity<Thread>,
-        language_registry: Arc<LanguageRegistry>,
-    ) -> Self {
+    pub fn new(thread: WeakEntity<Thread>, language_registry: Arc<LanguageRegistry>) -> Self {
        Self {
-            project,
            thread,
            language_registry,
        }
@@ -201,50 +194,22 @@ impl AgentTool for EditFileTool {
        acp::ToolKind::Edit
    }

-    fn initial_title(
-        &self,
-        input: Result<Self::Input, serde_json::Value>,
-        cx: &mut App,
-    ) -> SharedString {
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
        match input {
-            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(),
+            Ok(input) => input.display_description.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()
@@ -579,7 +544,7 @@ mod tests {
        let model = Arc::new(FakeLanguageModel::default());
        let thread = cx.new(|cx| {
            Thread::new(
-                project.clone(),
+                project,
                cx.new(|_cx| ProjectContext::default()),
                context_server_registry,
                Templates::new(),
@@ -594,12 +559,11 @@ mod tests {
                    path: "root/nonexistent_file.txt".into(),
                    mode: EditFileMode::Edit,
                };
-                Arc::new(EditFileTool::new(
-                    project,
-                    thread.downgrade(),
-                    language_registry,
-                ))
-                .run(input, ToolCallEventStream::test().0, cx)
+                Arc::new(EditFileTool::new(thread.downgrade(), language_registry)).run(
+                    input,
+                    ToolCallEventStream::test().0,
+                    cx,
+                )
            })
            .await;
        assert_eq!(
@@ -778,7 +742,7 @@ mod tests {
        let model = Arc::new(FakeLanguageModel::default());
        let thread = cx.new(|cx| {
            Thread::new(
-                project.clone(),
+                project,
                cx.new(|_cx| ProjectContext::default()),
                context_server_registry,
                Templates::new(),
@@ -810,7 +774,6 @@ mod tests {
                    mode: EditFileMode::Overwrite,
                };
                Arc::new(EditFileTool::new(
-                    project.clone(),
                    thread.downgrade(),
                    language_registry.clone(),
                ))
@@ -869,12 +832,11 @@ mod tests {
                    path: "root/src/main.rs".into(),
                    mode: EditFileMode::Overwrite,
                };
-                Arc::new(EditFileTool::new(
-                    project.clone(),
-                    thread.downgrade(),
-                    language_registry,
-                ))
-                .run(input, ToolCallEventStream::test().0, cx)
+                Arc::new(EditFileTool::new(thread.downgrade(), language_registry)).run(
+                    input,
+                    ToolCallEventStream::test().0,
+                    cx,
+                )
            });

            // Stream the unformatted content
@@ -922,7 +884,7 @@ mod tests {
        let model = Arc::new(FakeLanguageModel::default());
        let thread = cx.new(|cx| {
            Thread::new(
-                project.clone(),
+                project,
                cx.new(|_cx| ProjectContext::default()),
                context_server_registry,
                Templates::new(),
@@ -955,7 +917,6 @@ mod tests {
                    mode: EditFileMode::Overwrite,
                };
                Arc::new(EditFileTool::new(
-                    project.clone(),
                    thread.downgrade(),
                    language_registry.clone(),
                ))
@@ -1007,12 +968,11 @@ mod tests {
                    path: "root/src/main.rs".into(),
                    mode: EditFileMode::Overwrite,
                };
-                Arc::new(EditFileTool::new(
-                    project.clone(),
-                    thread.downgrade(),
-                    language_registry,
-                ))
-                .run(input, ToolCallEventStream::test().0, cx)
+                Arc::new(EditFileTool::new(thread.downgrade(), language_registry)).run(
+                    input,
+                    ToolCallEventStream::test().0,
+                    cx,
+                )
            });

            // Stream the content with trailing whitespace
@@ -1051,7 +1011,7 @@ mod tests {
        let model = Arc::new(FakeLanguageModel::default());
        let thread = cx.new(|cx| {
            Thread::new(
-                project.clone(),
+                project,
                cx.new(|_cx| ProjectContext::default()),
                context_server_registry,
                Templates::new(),
@@ -1059,11 +1019,7 @@ mod tests {
                cx,
            )
        });
-        let tool = Arc::new(EditFileTool::new(
-            project.clone(),
-            thread.downgrade(),
-            language_registry,
-        ));
+        let tool = Arc::new(EditFileTool::new(thread.downgrade(), language_registry));
        fs.insert_tree("/root", json!({})).await;

        // Test 1: Path with .zed component should require confirmation
@@ -1191,7 +1147,7 @@ mod tests {
        let model = Arc::new(FakeLanguageModel::default());
        let thread = cx.new(|cx| {
            Thread::new(
-                project.clone(),
+                project,
                cx.new(|_cx| ProjectContext::default()),
                context_server_registry,
                Templates::new(),
@@ -1199,11 +1155,7 @@ mod tests {
                cx,
            )
        });
-        let tool = Arc::new(EditFileTool::new(
-            project.clone(),
-            thread.downgrade(),
-            language_registry,
-        ));
+        let tool = Arc::new(EditFileTool::new(thread.downgrade(), language_registry));

        // Test global config paths - these should require confirmation if they exist and are outside the project
        let test_cases = vec![
@@ -1311,11 +1263,7 @@ mod tests {
                cx,
            )
        });
-        let tool = Arc::new(EditFileTool::new(
-            project.clone(),
-            thread.downgrade(),
-            language_registry,
-        ));
+        let tool = Arc::new(EditFileTool::new(thread.downgrade(), language_registry));

        // Test files in different worktrees
        let test_cases = vec![
@@ -1395,11 +1343,7 @@ mod tests {
                cx,
            )
        });
-        let tool = Arc::new(EditFileTool::new(
-            project.clone(),
-            thread.downgrade(),
-            language_registry,
-        ));
+        let tool = Arc::new(EditFileTool::new(thread.downgrade(), language_registry));

        // Test edge cases
        let test_cases = vec![
@@ -1482,11 +1426,7 @@ mod tests {
                cx,
            )
        });
-        let tool = Arc::new(EditFileTool::new(
-            project.clone(),
-            thread.downgrade(),
-            language_registry,
-        ));
+        let tool = Arc::new(EditFileTool::new(thread.downgrade(), language_registry));

        // Test different EditFileMode values
        let modes = vec![
@@ -1566,67 +1506,48 @@ mod tests {
                cx,
            )
        });
-        let tool = Arc::new(EditFileTool::new(
-            project,
-            thread.downgrade(),
-            language_registry,
-        ));
+        let tool = Arc::new(EditFileTool::new(thread.downgrade(), language_registry));

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

    #[gpui::test]
@@ -1653,11 +1574,7 @@ mod tests {

        // Ensure the diff is finalized after the edit completes.
        {
-            let tool = Arc::new(EditFileTool::new(
-                project.clone(),
-                thread.downgrade(),
-                languages.clone(),
-            ));
+            let tool = Arc::new(EditFileTool::new(thread.downgrade(), languages.clone()));
            let (stream_tx, mut stream_rx) = ToolCallEventStream::test();
            let edit = cx.update(|cx| {
                tool.run(
@@ -1682,11 +1599,7 @@ mod tests {
        // Ensure the diff is finalized if an error occurs while editing.
        {
            model.forbid_requests();
-            let tool = Arc::new(EditFileTool::new(
-                project.clone(),
-                thread.downgrade(),
-                languages.clone(),
-            ));
+            let tool = Arc::new(EditFileTool::new(thread.downgrade(), languages.clone()));
            let (stream_tx, mut stream_rx) = ToolCallEventStream::test();
            let edit = cx.update(|cx| {
                tool.run(
@@ -1709,11 +1622,7 @@ mod tests {

        // Ensure the diff is finalized if the tool call gets dropped.
        {
-            let tool = Arc::new(EditFileTool::new(
-                project.clone(),
-                thread.downgrade(),
-                languages.clone(),
-            ));
+            let tool = Arc::new(EditFileTool::new(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,11 +126,7 @@ impl AgentTool for FetchTool {
        acp::ToolKind::Fetch
    }

-    fn initial_title(
-        &self,
-        input: Result<Self::Input, serde_json::Value>,
-        _cx: &mut App,
-    ) -> SharedString {
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> 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,11 +93,7 @@ impl AgentTool for FindPathTool {
        acp::ToolKind::Search
    }

-    fn initial_title(
-        &self,
-        input: Result<Self::Input, serde_json::Value>,
-        _cx: &mut App,
-    ) -> SharedString {
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> 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,11 +75,7 @@ impl AgentTool for GrepTool {
        acp::ToolKind::Search
    }

-    fn initial_title(
-        &self,
-        input: Result<Self::Input, serde_json::Value>,
-        _cx: &mut App,
-    ) -> SharedString {
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> 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,11 +59,7 @@ impl AgentTool for ListDirectoryTool {
        ToolKind::Read
    }

-    fn initial_title(
-        &self,
-        input: Result<Self::Input, serde_json::Value>,
-        _cx: &mut App,
-    ) -> SharedString {
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> 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,11 +60,7 @@ impl AgentTool for MovePathTool {
        ToolKind::Move
    }

-    fn initial_title(
-        &self,
-        input: Result<Self::Input, serde_json::Value>,
-        _cx: &mut App,
-    ) -> SharedString {
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> 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,7 +11,6 @@ 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,
@@ -41,11 +40,7 @@ impl AgentTool for NowTool {
        acp::ToolKind::Other
    }

-    fn initial_title(
-        &self,
-        _input: Result<Self::Input, serde_json::Value>,
-        _cx: &mut App,
-    ) -> SharedString {
+    fn initial_title(&self, _input: Result<Self::Input, serde_json::Value>) -> SharedString {
        "Get current time".into()
    }

--- a/crates/agent2/src/tools/open_tool.rs
+++ b/crates/agent2/src/tools/open_tool.rs
@@ -45,11 +45,7 @@ impl AgentTool for OpenTool {
        ToolKind::Execute
    }

-    fn initial_title(
-        &self,
-        input: Result<Self::Input, serde_json::Value>,
-        _cx: &mut App,
-    ) -> SharedString {
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
        if let Ok(input) = input {
            format!("Open `{}`", MarkdownEscaped(&input.path_or_url)).into()
        } else {
@@ -65,7 +61,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), cx);
+        let authorize = event_stream.authorize(self.initial_title(Ok(input.clone())), 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::sync::Arc;
+use std::{path::Path, sync::Arc};
 use util::markdown::MarkdownCodeBlock;

 use crate::{AgentTool, ToolCallEventStream};
@@ -68,31 +68,13 @@ impl AgentTool for ReadFileTool {
        acp::ToolKind::Read
    }

-    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 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 run(
@@ -104,12 +86,6 @@ 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);
@@ -145,14 +121,6 @@ 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
@@ -261,25 +229,34 @@ impl AgentTool for ReadFileTool {
            };

            project.update(cx, |project, 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();
+                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,
+                    );
                    event_stream.update_fields(ToolCallUpdateFields {
-                        content: Some(vec![acp::ToolCallContent::Content {
-                            content: markdown.into(),
+                        locations: Some(vec![acp::ToolCallLocation {
+                            path: abs_path,
+                            line: input.start_line.map(|line| line.saturating_sub(1)),
                        }]),
                        ..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,11 +60,7 @@ impl AgentTool for TerminalTool {
        acp::ToolKind::Execute
    }

-    fn initial_title(
-        &self,
-        input: Result<Self::Input, serde_json::Value>,
-        _cx: &mut App,
-    ) -> SharedString {
+    fn initial_title(&self, input: Result<Self::Input, serde_json::Value>) -> SharedString {
        if let Ok(input) = input {
            let mut lines = input.command.lines();
            let first_line = lines.next().unwrap_or_default();
@@ -97,7 +93,7 @@ impl AgentTool for TerminalTool {
            Err(err) => return Task::ready(Err(err)),
        };

-        let authorize = event_stream.authorize(self.initial_title(Ok(input.clone()), cx), cx);
+        let authorize = event_stream.authorize(self.initial_title(Ok(input.clone())), 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,11 +29,7 @@ impl AgentTool for ThinkingTool {
        acp::ToolKind::Think
    }

-    fn initial_title(
-        &self,
-        _input: Result<Self::Input, serde_json::Value>,
-        _cx: &mut App,
-    ) -> SharedString {
+    fn initial_title(&self, _input: Result<Self::Input, serde_json::Value>) -> SharedString {
        "Thinking".into()
    }

--- a/crates/agent2/src/tools/web_search_tool.rs
+++ b/crates/agent2/src/tools/web_search_tool.rs
@@ -48,11 +48,7 @@ impl AgentTool for WebSearchTool {
        acp::ToolKind::Fetch
    }

-    fn initial_title(
-        &self,
-        _input: Result<Self::Input, serde_json::Value>,
-        _cx: &mut App,
-    ) -> SharedString {
+    fn initial_title(&self, _input: Result<Self::Input, serde_json::Value>) -> 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
+client = { workspace = true, optional = true }
 collections.workspace = true
 env_logger = { workspace = true, optional = true }
 fs.workspace = true
@@ -35,18 +35,22 @@ 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,3 +1,4 @@
+use crate::AgentServerCommand;
 use acp_thread::AgentConnection;
 use acp_tools::AcpConnectionRegistry;
 use action_log::ActionLog;
@@ -7,10 +8,8 @@ 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;
@@ -30,7 +29,6 @@ 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<()>>,
@@ -45,10 +43,9 @@ 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, is_remote, cx).await?;
+    let conn = AcpConnection::stdio(server_name, command.clone(), root_dir, cx).await?;
    Ok(Rc::new(conn) as _)
 }

@@ -59,21 +56,17 @@ 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);
-        child
+        let mut child = util::command::new_smol_command(command.path)
            .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);
-        if !is_remote {
-            child.current_dir(root_dir);
-        }
-        let mut child = child.spawn()?;
+            .kill_on_drop(true)
+            .spawn()?;

        let stdout = child.stdout.take().context("Failed to take stdout")?;
        let stdin = child.stdin.take().context("Failed to take stdin")?;
@@ -152,7 +145,6 @@ impl AcpConnection {

        Ok(Self {
            auth_methods: response.auth_methods,
-            root_dir: root_dir.to_owned(),
            connection,
            server_name,
            sessions,
@@ -166,10 +158,6 @@ 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 {
@@ -183,36 +171,29 @@ 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 = 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![]
-                        },
-                    })
+        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![]
+                    },
                })
-                .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()
-        };
+            })
+            .collect();

        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,25 +2,47 @@ 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 project::agent_server_store::AgentServerStore;
+use gpui::AppContext;
+use node_runtime::NodeRuntime;
+pub use settings::*;

 use acp_thread::AgentConnection;
+use acp_thread::LoadError;
 use anyhow::Result;
-use gpui::{App, Entity, SharedString, Task};
+use anyhow::anyhow;
+use collections::HashMap;
+use gpui::{App, AsyncApp, Entity, SharedString, Task};
 use project::Project;
-use std::{any::Any, path::Path, rc::Rc};
+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 _;

-pub use acp::AcpConnection;
+pub fn init(cx: &mut App) {
+    settings::init(cx);
+}

 pub struct AgentServerDelegate {
-    store: Entity<AgentServerStore>,
    project: Entity<Project>,
    status_tx: Option<watch::Sender<SharedString>>,
    new_version_available: Option<watch::Sender<Option<String>>>,
@@ -28,13 +50,11 @@ 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,
@@ -44,6 +64,188 @@ 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 {
@@ -53,10 +255,10 @@ pub trait AgentServer: Send {

    fn connect(
        &self,
-        root_dir: Option<&Path>,
+        root_dir: &Path,
        delegate: AgentServerDelegate,
        cx: &mut App,
-    ) -> Task<Result<(Rc<dyn AgentConnection>, Option<task::SpawnInTerminal>)>>;
+    ) -> Task<Result<Rc<dyn AgentConnection>>>;

    fn into_any(self: Rc<Self>) -> Rc<dyn Any>;
 }
@@ -66,3 +268,120 @@ 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,22 +1,61 @@
+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::{Context as _, Result};
-use gpui::{App, SharedString, Task};
-use project::agent_server_store::CLAUDE_CODE_NAME;
+use anyhow::Result;
+use gpui::{App, AppContext as _, SharedString, Task};

-use crate::{AgentServer, AgentServerDelegate};
+use crate::{AgentServer, AgentServerDelegate, AllAgentServersSettings};
 use acp_thread::AgentConnection;

 #[derive(Clone)]
 pub struct ClaudeCode;

-pub struct AgentServerLoginCommand {
+pub struct ClaudeCodeLoginCommand {
    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"
@@ -32,33 +71,53 @@ impl AgentServer for ClaudeCode {

    fn connect(
        &self,
-        root_dir: Option<&Path>,
+        root_dir: &Path,
        delegate: AgentServerDelegate,
        cx: &mut App,
-    ) -> 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();
+    ) -> 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()
+        });

        cx.spawn(async move |cx| {
-            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))
+            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
        })
    }

--- a/crates/agent_servers/src/custom.rs
+++ b/crates/agent_servers/src/custom.rs
@@ -1,19 +1,19 @@
-use crate::AgentServerDelegate;
+use crate::{AgentServerCommand, AgentServerDelegate};
 use acp_thread::AgentConnection;
-use anyhow::{Context as _, Result};
+use anyhow::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) -> Self {
-        Self { name }
+    pub fn new(name: SharedString, command: AgentServerCommand) -> Self {
+        Self { name, command }
    }
 }

@@ -32,36 +32,14 @@ impl crate::AgentServer for CustomAgentServer {

    fn connect(
        &self,
-        root_dir: Option<&Path>,
-        delegate: AgentServerDelegate,
+        root_dir: &Path,
+        _delegate: AgentServerDelegate,
        cx: &mut App,
-    ) -> 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))
-        })
+    ) -> 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)
    }

    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;
-#[cfg(test)]
-use project::agent_server_store::{AgentServerCommand, CustomAgentServerSettings};
-use project::{FakeFs, Project, agent_server_store::AllAgentServersSettings};
+use project::{FakeFs, Project};
 use std::{
    path::{Path, PathBuf},
    sync::Arc,
@@ -449,6 +449,7 @@ 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();
@@ -467,11 +468,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);
-        AllAgentServersSettings::register(cx);
+        crate::settings::init(cx);

        #[cfg(test)]
-        AllAgentServersSettings::override_global(
-            AllAgentServersSettings {
+        crate::AllAgentServersSettings::override_global(
+            crate::AllAgentServersSettings {
                claude: Some(CustomAgentServerSettings {
                    command: AgentServerCommand {
                        path: "claude-code-acp".into(),
@@ -497,11 +498,10 @@ pub async fn new_test_thread(
    current_dir: impl AsRef<Path>,
    cx: &mut TestAppContext,
 ) -> Entity<AcpThread> {
-    let store = project.read_with(cx, |project, _| project.agent_server_store().clone());
-    let delegate = AgentServerDelegate::new(store, project.clone(), None, None);
+    let delegate = AgentServerDelegate::new(project.clone(), None, None);

-    let (connection, _) = cx
-        .update(|cx| server.connect(Some(current_dir.as_ref()), delegate, cx))
+    let connection = cx
+        .update(|cx| server.connect(current_dir.as_ref(), delegate, cx))
        .await
        .unwrap();

--- a/crates/agent_servers/src/gemini.rs
+++ b/crates/agent_servers/src/gemini.rs
@@ -1,19 +1,21 @@
 use std::rc::Rc;
 use std::{any::Any, path::Path};

+use crate::acp::AcpConnection;
 use crate::{AgentServer, AgentServerDelegate};
-use acp_thread::AgentConnection;
-use anyhow::{Context as _, Result};
-use client::ProxySettings;
-use collections::HashMap;
-use gpui::{App, AppContext, SharedString, Task};
+use acp_thread::{AgentConnection, LoadError};
+use anyhow::Result;
+use gpui::{App, AppContext as _, 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"
@@ -29,49 +31,120 @@ impl AgentServer for Gemini {

    fn connect(
        &self,
-        root_dir: Option<&Path>,
+        root_dir: &Path,
        delegate: AgentServerDelegate,
        cx: &mut App,
-    ) -> 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()
+    ) -> 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()
        });

        cx.spawn(async move |cx| {
-            let mut extra_env = HashMap::default();
-            if let Some(api_key) = cx.update(GoogleLanguageModelProvider::api_key)?.await.ok() {
-                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"))
+            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.args.push("--proxy".into());
-                command.args.push(proxy_url_value.clone());
+                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 connection =
-                crate::acp::connect(name, command, root_dir.as_ref(), is_remote, cx).await?;
-            Ok((connection, login))
+            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);
+            }
+
+            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
        })
    }

@@ -80,11 +153,18 @@ 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
@@ -0,0 +1,111 @@
+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, SettingsKey, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsSources, SettingsUi};
 use std::borrow::Cow;

 pub use crate::agent_profile::*;
@@ -223,8 +223,7 @@ impl AgentSettingsContent {
    }
 }

-#[derive(Clone, Serialize, Deserialize, JsonSchema, Debug, Default, SettingsUi, SettingsKey)]
-#[settings_key(key = "agent", fallback_key = "assistant")]
+#[derive(Clone, Serialize, Deserialize, JsonSchema, Debug, Default, SettingsUi)]
 pub struct AgentSettingsContent {
    /// Whether the Agent is enabled.
    ///
@@ -400,6 +399,10 @@ 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,31 +1025,43 @@ impl SlashCommandCompletion {
            return None;
        }

-        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)
+        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())
        {
            return None;
        }

-        let mut argument = None;
+        let rest_of_line = &line[last_command_start + 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());
-            }
+        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());
-        } else if !last_command.is_empty() {
-            command = Some(last_command.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;
+                }
+            }
+        }

        Some(Self {
-            source_range: prefix.len() + offset_to_line
-                ..line
-                    .rfind(|c: char| !c.is_whitespace())
-                    .unwrap_or_else(|| line.len())
-                    + 1
-                    + offset_to_line,
+            source_range: last_command_start + offset_to_line..end + offset_to_line,
            command,
            argument,
        })
@@ -1168,15 +1180,6 @@ 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);
@@ -1184,8 +1187,6 @@ 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]
--- 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 agent_font_size_changed(&mut self, cx: &mut App) {
+    pub fn settings_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,13 +493,14 @@ 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 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 {
+        let Some(worktree) = self.project.read(cx).worktree_for_entry(entry.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)
            })?;
@@ -699,15 +700,10 @@ impl MessageEditor {
            self.project.read(cx).fs().clone(),
            self.history_store.clone(),
        ));
-        let delegate = AgentServerDelegate::new(
-            self.project.read(cx).agent_server_store().clone(),
-            self.project.clone(),
-            None,
-            None,
-        );
-        let connection = server.connect(None, delegate, cx);
+        let delegate = AgentServerDelegate::new(self.project.clone(), None, None);
+        let connection = server.connect(Path::new(""), 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,10 +192,8 @@ impl PickerDelegate for AcpModelPickerDelegate {
        }
    }

-    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 dismissed(&mut self, _: &mut Window, cx: &mut Context<Picker<Self>>) {
+        cx.emit(DismissEvent);
    }

    fn render_match(
--- a/crates/agent_ui/src/acp/model_selector_popover.rs
+++ b/crates/agent_ui/src/acp/model_selector_popover.rs
@@ -5,8 +5,7 @@ use agent_client_protocol as acp;
 use gpui::{Entity, FocusHandle};
 use picker::popover_menu::PickerPopoverMenu;
 use ui::{
-    ButtonLike, Context, IntoElement, PopoverMenuHandle, SharedString, TintColor, Tooltip, Window,
-    prelude::*,
+    ButtonLike, Context, IntoElement, PopoverMenuHandle, SharedString, Tooltip, Window, prelude::*,
 };
 use zed_actions::agent::ToggleModelSelector;

@@ -59,22 +58,15 @@ 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).size(IconSize::XSmall))
+                    this.child(Icon::new(icon).color(Color::Muted).size(IconSize::XSmall))
                })
-                .selected_style(ButtonStyle::Tinted(TintColor::Accent))
                .child(
                    Label::new(model_name)
-                        .color(color)
+                        .color(Color::Muted)
                        .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};
+use agent_servers::{AgentServer, AgentServerDelegate, ClaudeCode};
 use agent_settings::{AgentProfileId, AgentSettings, CompletionMode, NotifyWhenAgentWaiting};
 use agent2::{DbThreadMetadata, HistoryEntry, HistoryEntryId, HistoryStore, NativeAgentServer};
 use anyhow::{Context as _, Result, anyhow, bail};
@@ -40,9 +40,10 @@ 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::{AgentFontSize, ThemeSettings};
+use theme::ThemeSettings;
 use ui::{
    Callout, CommonAnimationExt, Disclosure, Divider, DividerColor, ElevationIndex, KeyBinding,
    PopoverMenuHandle, Scrollbar, ScrollbarState, SpinnerLabel, TintColor, Tooltip, prelude::*,
@@ -262,7 +263,6 @@ 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; 4],
+    _subscriptions: [Subscription; 3],
 }

 enum ThreadState {
@@ -380,8 +380,7 @@ impl AcpThreadView {
        });

        let subscriptions = [
-            cx.observe_global_in::<SettingsStore>(window, Self::agent_font_size_changed),
-            cx.observe_global_in::<AgentFontSize>(window, Self::agent_font_size_changed),
+            cx.observe_global_in::<SettingsStore>(window, Self::settings_changed),
            cx.subscribe_in(&message_editor, window, Self::handle_message_editor_event),
            cx.subscribe_in(&entry_view_state, window, Self::handle_entry_view_event),
        ];
@@ -392,7 +391,6 @@ 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,
@@ -445,11 +443,9 @@ impl AcpThreadView {
        window: &mut Window,
        cx: &mut Context<Self>,
    ) -> ThreadState {
-        if project.read(cx).is_via_collab()
-            && agent.clone().downcast::<NativeAgentServer>().is_none()
-        {
+        if !project.read(cx).is_local() && agent.clone().downcast::<NativeAgentServer>().is_none() {
            return ThreadState::LoadError(LoadError::Other(
-                "External agents are not yet supported in shared projects.".into(),
+                "External agents are not yet supported for remote projects.".into(),
            ));
        }
        let mut worktrees = project.read(cx).visible_worktrees(cx).collect::<Vec<_>>();
@@ -469,23 +465,20 @@ impl AcpThreadView {
                    Some(worktree.read(cx).abs_path())
                }
            })
-            .next();
+            .next()
+            .unwrap_or_else(|| paths::home_dir().as_path().into());
        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.as_deref(), delegate, cx);
+        let connect_task = agent.connect(&root_dir, delegate, cx);
        let load_task = cx.spawn_in(window, async move |this, cx| {
            let connection = match connect_task.await {
-                Ok((connection, login)) => {
-                    this.update(cx, |this, _| this.login = login).ok();
-                    connection
-                }
+                Ok(connection) => connection,
                Err(err) => {
                    this.update_in(cx, |this, window, cx| {
                        if err.downcast_ref::<LoadError>().is_some() {
@@ -512,14 +505,6 @@ 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()
@@ -927,7 +912,7 @@ impl AcpThreadView {
                }
            }
            ViewEvent::MessageEditorEvent(editor, MessageEditorEvent::Send) => {
-                self.regenerate(event.entry_index, editor.clone(), window, cx);
+                self.regenerate(event.entry_index, editor, window, cx);
            }
            ViewEvent::MessageEditorEvent(_editor, MessageEditorEvent::Cancel) => {
                self.cancel_editing(&Default::default(), window, cx);
@@ -998,7 +983,7 @@ impl AcpThreadView {
                    this,
                    AuthRequired {
                        description: None,
-                        provider_id: None,
+                        provider_id: Some(language_model::ANTHROPIC_PROVIDER_ID),
                    },
                    agent,
                    connection,
@@ -1151,7 +1136,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>,
    ) {
@@ -1168,18 +1153,16 @@ impl AcpThreadView {
            return;
        };

-        cx.spawn_in(window, async move |this, cx| {
+        let contents = message_editor.update(cx, |message_editor, cx| message_editor.contents(cx));
+
+        let task = cx.spawn(async move |_, cx| {
+            let contents = contents.await?;
            thread
                .update(cx, |thread, cx| thread.rewind(user_message_id, cx))?
                .await?;
-            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();
+            Ok(contents)
+        });
+        self.send_impl(task, window, cx);
    }

    fn open_agent_diff(&mut self, _: &OpenAgentDiff, window: &mut Window, cx: &mut Context<Self>) {
@@ -1478,12 +1461,9 @@ impl AcpThreadView {
        self.thread_error.take();
        configuration_view.take();
        pending_auth_method.replace(method.clone());
-        let authenticate = if (method.0.as_ref() == "claude-login"
-            || method.0.as_ref() == "spawn-gemini-cli")
-            && let Some(login) = self.login.clone()
-        {
+        let authenticate = if method.0.as_ref() == "claude-login" {
            if let Some(workspace) = self.workspace.upgrade() {
-                Self::spawn_external_agent_login(login, workspace, false, window, cx)
+                Self::spawn_claude_login(&workspace, window, cx)
            } else {
                Task::ready(Ok(()))
            }
@@ -1530,28 +1510,31 @@ impl AcpThreadView {
            }));
    }

-    fn spawn_external_agent_login(
-        login: task::SpawnInTerminal,
-        workspace: Entity<Workspace>,
-        previous_attempt: bool,
+    fn spawn_claude_login(
+        workspace: &Entity<Workspace>,
        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 = 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();
+        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);

        window.spawn(cx, async move |cx| {
-            let mut task = login.clone();
-            task.command = task
-                .command
-                .map(|command| anyhow::Ok(shlex::try_quote(&command)?.to_string()))
-                .transpose()?;
-            task.args = task
-                .args
+            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
                .iter()
                .map(|arg| {
                    Ok(shlex::try_quote(arg)
@@ -1559,16 +1542,26 @@ 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(&login, 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,
+                )
            })?;

            let terminal = terminal.await?;
@@ -1584,9 +1577,7 @@ 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")
-                                || content.contains("Type your message")
-                            {
+                            if content.contains("Login successful") {
                                return anyhow::Ok(());
                            }
                        }
@@ -1602,9 +1593,6 @@ 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"));
                }
            }
@@ -1637,16 +1625,14 @@ impl AcpThreadView {
        cx.notify();
    }

-    fn restore_checkpoint(&mut self, message_id: &UserMessageId, cx: &mut Context<Self>) {
+    fn rewind(&mut self, message_id: &UserMessageId, cx: &mut Context<Self>) {
        let Some(thread) = self.thread() else {
            return;
        };
-
        thread
-            .update(cx, |thread, cx| {
-                thread.restore_checkpoint(message_id.clone(), cx)
-            })
+            .update(cx, |thread, cx| thread.rewind(message_id.clone(), cx))
            .detach_and_log_err(cx);
+        cx.notify();
    }

    fn render_entry(
@@ -1716,9 +1702,8 @@ 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.restore_checkpoint(&message_id, cx);
+                                            this.rewind(&message_id, cx);
                                        }))
                                )
                                .child(Divider::horizontal())
@@ -1789,7 +1774,7 @@ impl AcpThreadView {
                                                            let editor = editor.clone();
                                                            move |this, _, window, cx| {
                                                                this.regenerate(
-                                                                    entry_ix, editor.clone(), window, cx,
+                                                                    entry_ix, &editor, window, cx,
                                                                );
                                                            }
                                                        })).into_any_element()
@@ -2038,34 +2023,35 @@ 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 && 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 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 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 { .. }
@@ -2208,6 +2194,13 @@ 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()
@@ -2218,13 +2211,7 @@ impl AcpThreadView {
                                            this.text_color(cx.theme().colors().text_muted)
                                        }
                                    })
-                                    .child(self.render_markdown(
-                                        tool_call.label.clone(),
-                                        MarkdownStyle {
-                                            prevent_mouse_interaction: true,
-                                            ..default_markdown_style(false, true, window, cx)
-                                        },
-                                    ))
+                                    .child(name)
                                    .tooltip(Tooltip::text("Jump to File"))
                                    .on_click(cx.listener(move |this, _, window, cx| {
                                        this.open_tool_call_location(entry_ix, 0, window, cx);
@@ -3023,8 +3010,6 @@ 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()
@@ -3055,23 +3040,21 @@ 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 {}.{}",
-                            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(
+                    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_some(pending_auth_method, |el, _| {
                    el.child(
                        h_flex()
@@ -3083,12 +3066,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(!auth_methods.is_empty(), |this| {
+                .when(!connection.auth_methods().is_empty(), |this| {
                    this.child(
                        h_flex()
                            .justify_end()
@@ -3100,26 +3083,23 @@ impl AcpThreadView {
                                    .pt_2()
                                    .border_color(cx.theme().colors().border.opacity(0.8))
                            })
-                            .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)
+                            .children(
+                                connection
+                                    .auth_methods()
+                                    .iter()
+                                    .enumerate()
+                                    .rev()
+                                    .map(|(ix, method)| {
+                                        Button::new(
+                                            SharedString::from(method.id.0.clone()),
+                                            method.name.clone(),
+                                        )
                                        .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",
@@ -3127,17 +3107,14 @@ impl AcpThreadView {
                                                    method = method_id
                                                );

-                                                this.authenticate(
-                                                    acp::AuthMethodId(method_id.clone()),
-                                                    window,
-                                                    cx,
-                                                )
+                                                this.authenticate(method_id.clone(), window, cx)
                                            })
                                        })
-                                },
-                            )),
+                                    }),
+                            ),
                    )
-                }),
+                })
+
        )
    }

@@ -4094,15 +4071,15 @@ impl AcpThreadView {
                MentionUri::PastedImage => {}
                MentionUri::Directory { abs_path } => {
                    let project = workspace.project();
-                    let Some(entry_id) = project.update(cx, |project, cx| {
+                    let Some(entry) = project.update(cx, |project, cx| {
                        let path = project.find_project_path(abs_path, cx)?;
-                        project.entry_for_path(&path, cx).map(|entry| entry.id)
+                        project.entry_for_path(&path, cx)
                    }) else {
                        return;
                    };

                    project.update(cx, |_, cx| {
-                        cx.emit(project::Event::RevealInProjectPanel(entry_id));
+                        cx.emit(project::Event::RevealInProjectPanel(entry.id));
                    });
                }
                MentionUri::Symbol {
@@ -4115,9 +4092,11 @@ impl AcpThreadView {
                    line_range,
                } => {
                    let project = workspace.project();
-                    let Some(path) =
-                        project.update(cx, |project, cx| project.find_project_path(path, cx))
-                    else {
+                    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 {
                        return;
                    };

@@ -4279,7 +4258,7 @@ impl AcpThreadView {
                }

                let buffer = project.update(cx, |project, cx| {
-                    project.create_local_buffer(&markdown, Some(markdown_language), true, cx)
+                    project.create_local_buffer(&markdown, Some(markdown_language), cx)
                });
                let buffer = cx.new(|cx| {
                    MultiBuffer::singleton(buffer, cx).with_title(thread_summary.clone())
@@ -4758,9 +4737,9 @@ impl AcpThreadView {
        )
    }

-    fn agent_font_size_changed(&mut self, _window: &mut Window, cx: &mut Context<Self>) {
+    fn settings_changed(&mut self, _window: &mut Window, cx: &mut Context<Self>) {
        self.entry_view_state.update(cx, |entry_view_state, cx| {
-            entry_view_state.agent_font_size_changed(cx);
+            entry_view_state.settings_changed(cx);
        });
    }

@@ -5010,7 +4989,6 @@ 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()
@@ -5737,11 +5715,11 @@ pub(crate) mod tests {

        fn connect(
            &self,
-            _root_dir: Option<&Path>,
+            _root_dir: &Path,
            _delegate: AgentServerDelegate,
            _cx: &mut App,
-        ) -> Task<gpui::Result<(Rc<dyn AgentConnection>, Option<task::SpawnInTerminal>)>> {
-            Task::ready(Ok((Rc::new(self.connection.clone()), None)))
+        ) -> Task<gpui::Result<Rc<dyn AgentConnection>>> {
+            Task::ready(Ok(Rc::new(self.connection.clone())))
        }

        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), true, cx)
+                project.create_local_buffer(&markdown, Some(markdown_language), 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,6 +5,7 @@ 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};
@@ -25,10 +26,6 @@ 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},
 };
@@ -48,13 +45,11 @@ 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>,
@@ -71,7 +66,6 @@ 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>,
@@ -110,7 +104,6 @@ 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(),
@@ -516,10 +509,8 @@ impl AgentConfiguration {

            let (plan_name, label_color, bg_color) = match plan {
                Plan::ZedFree => ("Free", Color::Default, free_chip_bg),
-                Plan::ZedProTrial | Plan::ZedProTrialV2 => {
-                    ("Pro Trial", Color::Accent, pro_chip_bg)
-                }
-                Plan::ZedPro | Plan::ZedProV2 => ("Pro", Color::Accent, pro_chip_bg),
+                Plan::ZedProTrial => ("Pro Trial", Color::Accent, pro_chip_bg),
+                Plan::ZedPro => ("Pro", Color::Accent, pro_chip_bg),
            };

            Chip::new(plan_name.to_string())
@@ -1000,30 +991,17 @@ impl AgentConfiguration {
    }

    fn render_agent_servers_section(&mut self, cx: &mut Context<Self>) -> impl IntoElement {
-        let custom_settings = cx
-            .global::<SettingsStore>()
-            .get::<AllAgentServersSettings>(None)
+        let settings = AllAgentServersSettings::get_global(cx).clone();
+        let user_defined_agents = settings
            .custom
-            .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| {
+            .iter()
+            .map(|(name, settings)| {
                self.render_agent_server(
                    IconName::Ai,
                    name.clone(),
                    ExternalAgent::Custom {
-                        name: name.clone().into(),
-                        command: custom_settings
-                            .get(&name.0)
-                            .map(|settings| settings.command.clone())
-                            .unwrap_or(placeholder_command()),
+                        name: name.clone(),
+                        command: settings.command.clone(),
                    },
                    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,7 +251,6 @@ pub struct ConfigureContextServerModal {
    workspace: WeakEntity<Workspace>,
    source: ConfigurationSource,
    state: State,
-    original_server_id: Option<ContextServerId>,
 }

 impl ConfigureContextServerModal {
@@ -349,11 +348,6 @@ 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,
@@ -421,19 +415,9 @@ 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();
-                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);
-                    },
-                );
+                update_settings_file::<ProjectSettings>(fs.clone(), cx, |project_settings, _| {
+                    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,11 +5,9 @@ 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};
@@ -35,9 +33,7 @@ use crate::{
    thread_history::{HistoryEntryElement, ThreadHistory},
    ui::{AgentOnboardingModal, EndTrialUpsell},
 };
-use crate::{
-    ExternalAgent, NewExternalAgentThread, NewNativeAgentThreadFromSummary, placeholder_command,
-};
+use crate::{ExternalAgent, NewExternalAgentThread, NewNativeAgentThreadFromSummary};
 use agent::{
    Thread, ThreadError, ThreadEvent, ThreadId, ThreadSummary, TokenUsageRatio,
    context_store::ContextStore,
@@ -66,7 +62,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, SettingsStore, update_settings_file};
+use settings::{Settings, update_settings_file};
 use theme::ThemeSettings;
 use time::UtcOffset;
 use ui::utils::WithRemSize;
@@ -1098,7 +1094,7 @@ impl AgentPanel {
        let workspace = self.workspace.clone();
        let project = self.project.clone();
        let fs = self.fs.clone();
-        let is_via_collab = self.project.read(cx).is_via_collab();
+        let is_not_local = !self.project.read(cx).is_local();

        const LAST_USED_EXTERNAL_AGENT_KEY: &str = "agent_panel__last_used_external_agent";

@@ -1130,7 +1126,7 @@ impl AgentPanel {
                    agent
                }
                None => {
-                    if is_via_collab {
+                    if is_not_local {
                        ExternalAgent::NativeAgent
                    } else {
                        cx.background_spawn(async move {
@@ -1507,7 +1503,6 @@ 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();
@@ -1516,7 +1511,6 @@ impl AgentPanel {
        self.configuration = Some(cx.new(|cx| {
            AgentConfiguration::new(
                fs,
-                agent_server_store,
                context_server_store,
                tools,
                self.language_registry.clone(),
@@ -2509,7 +2503,6 @@ 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 {
@@ -2538,14 +2531,12 @@ impl AgentPanel {
                    }
                },
            )
-            .anchor(Corner::TopRight)
+            .anchor(Corner::TopLeft)
            .with_handle(self.new_thread_menu_handle.clone())
            .menu({
                let workspace = self.workspace.clone();
-                let is_via_collab = workspace
-                    .update(cx, |workspace, cx| {
-                        workspace.project().read(cx).is_via_collab()
-                    })
+                let is_not_local = workspace
+                    .update(cx, |workspace, cx| !workspace.project().read(cx).is_local())
                    .unwrap_or_default();

                move |window, cx| {
@@ -2637,7 +2628,7 @@ impl AgentPanel {
                                    ContextMenuEntry::new("New Gemini CLI Thread")
                                        .icon(IconName::AiGemini)
                                        .icon_color(Color::Muted)
-                                        .disabled(is_via_collab)
+                                        .disabled(is_not_local)
                                        .handler({
                                            let workspace = workspace.clone();
                                            move |window, cx| {
@@ -2664,7 +2655,7 @@ impl AgentPanel {
                                menu.item(
                                    ContextMenuEntry::new("New Claude Code Thread")
                                        .icon(IconName::AiClaude)
-                                        .disabled(is_via_collab)
+                                        .disabled(is_not_local)
                                        .icon_color(Color::Muted)
                                        .handler({
                                            let workspace = workspace.clone();
@@ -2689,25 +2680,19 @@ impl AgentPanel {
                                )
                            })
                            .when(cx.has_flag::<GeminiAndNativeFeatureFlag>(), |mut menu| {
-                                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 {
+                                // Add custom agents from settings
+                                let settings =
+                                    agent_servers::AllAgentServersSettings::get_global(cx);
+                                for (agent_name, agent_settings) in &settings.custom {
                                    menu = menu.item(
                                        ContextMenuEntry::new(format!("New {} Thread", agent_name))
                                            .icon(IconName::Terminal)
                                            .icon_color(Color::Muted)
-                                            .disabled(is_via_collab)
+                                            .disabled(is_not_local)
                                            .handler({
                                                let workspace = workspace.clone();
                                                let agent_name = agent_name.clone();
-                                                let custom_settings = custom_settings.clone();
+                                                let agent_settings = agent_settings.clone();
                                                move |window, cx| {
                                                    if let Some(workspace) = workspace.upgrade() {
                                                        workspace.update(cx, |workspace, cx| {
@@ -2718,9 +2703,10 @@ impl AgentPanel {
                                                                    panel.new_agent_thread(
                                                                        AgentType::Custom {
                                                                            name: agent_name
-                                                                                .clone()
-                                                                                .into(),
-                                                                            command: custom_settings.get(&agent_name.0).map(|settings| settings.command.clone()).unwrap_or(placeholder_command())
+                                                                                .clone(),
+                                                                            command: agent_settings
+                                                                                .command
+                                                                                .clone(),
                                                                        },
                                                                        window,
                                                                        cx,
@@ -3518,7 +3504,6 @@ 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,6 +28,7 @@ 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;
@@ -40,7 +41,6 @@ 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,14 +174,6 @@ enum ExternalAgent {
    },
 }

-fn placeholder_command() -> AgentServerCommand {
-    AgentServerCommand {
-        path: "/placeholder".into(),
-        args: vec![],
-        env: None,
-    }
-}
-
 impl ExternalAgent {
    fn name(&self) -> &'static str {
        match self {
@@ -201,9 +193,10 @@ 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()))
-            }
+            Self::Custom { name, command } => Rc::new(agent_servers::CustomAgentServer::new(
+                name.clone(),
+                command.clone(),
+            )),
        }
    }
 }
@@ -344,7 +337,8 @@ 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>()]);
+            filter
+                .show_action_types([TypeId::of::<zed_actions::OpenZedPredictOnboarding>()].iter());
        }
    });
 }
--- 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.random_range(1..=max_len);
+            let len = rng.gen_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.random_range(1..=max_len);
+            let len = rng.gen_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.random_range(1..=max_len);
+            let len = rng.gen_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,8 +987,7 @@ impl MentionLink {
                    .read(cx)
                    .project()
                    .read(cx)
-                    .entry_for_path(&project_path, cx)?
-                    .clone();
+                    .entry_for_path(&project_path, cx)?;
                Some(MentionLink::File(project_path, entry))
            }
            Self::SYMBOL => {
--- a/crates/agent_ui/src/context_picker/symbol_context_picker.rs
+++ b/crates/agent_ui/src/context_picker/symbol_context_picker.rs
@@ -303,7 +303,7 @@ pub(crate) fn search_symbols(
        };

        const MAX_MATCHES: usize = 100;
-        let mut visible_matches = cx.foreground_executor().block_on(fuzzy::match_strings(
+        let mut visible_matches = cx.background_executor().block(fuzzy::match_strings(
            &visible_match_candidates,
            &query,
            false,
@@ -312,7 +312,7 @@ pub(crate) fn search_symbols(
            &cancellation_flag,
            cx.background_executor().clone(),
        ));
-        let mut external_matches = cx.foreground_executor().block_on(fuzzy::match_strings(
+        let mut external_matches = cx.background_executor().block(fuzzy::match_strings(
            &external_match_candidates,
            &query,
            false,
--- a/crates/agent_ui/src/inline_prompt_editor.rs
+++ b/crates/agent_ui/src/inline_prompt_editor.rs
@@ -1,18 +1,29 @@
+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, Context, CursorStyle, Entity, EventEmitter, FocusHandle, Focusable,
-    Subscription, TextStyle, WeakEntity, Window,
+    AnyElement, App, ClickEvent, Context, CursorStyle, Entity, EventEmitter, FocusHandle,
+    Focusable, FontWeight, Subscription, TextStyle, WeakEntity, Window, anchored, deferred, point,
 };
 use language_model::{LanguageModel, LanguageModelRegistry};
 use parking_lot::Mutex;
@@ -22,19 +33,12 @@ use std::rc::Rc;
 use std::sync::Arc;
 use theme::ThemeSettings;
 use ui::utils::WithRemSize;
-use ui::{IconButtonShape, KeyBinding, PopoverMenuHandle, Tooltip, prelude::*};
+use ui::{
+    CheckboxWithLabel, IconButtonShape, KeyBinding, Popover, 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,
@@ -140,16 +144,47 @@ impl<T: 'static> Render for PromptEditor<T> {
                                };

                                let error_message = SharedString::from(error.to_string());
-                                el.child(
-                                    div()
-                                        .id("error")
-                                        .tooltip(Tooltip::text(error_message))
-                                        .child(
-                                            Icon::new(IconName::XCircle)
-                                                .size(IconSize::Small)
-                                                .color(Color::Error),
-                                        ),
-                                )
+                                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),
+                                            ),
+                                    )
+                                }
                            }),
                    )
                    .child(
@@ -275,6 +310,19 @@ 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>,
@@ -659,6 +707,61 @@ 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();

@@ -875,7 +978,15 @@ impl PromptEditor<BufferCodegen> {
                self.editor
                    .update(cx, |editor, _| editor.set_read_only(false));
            }
-            CodegenStatus::Error(_error) => {
+            CodegenStatus::Error(error) => {
+                if cx.has_flag::<ZedProFeatureFlag>()
+                    && error.error_code() == proto::ErrorCode::RateLimitExceeded
+                    && !RateLimitNotice::dismissed()
+                {
+                    self.show_rate_limit_notice = true;
+                    cx.notify();
+                }
+
                self.edited_since_done = false;
                self.editor
                    .update(cx, |editor, _| editor.set_read_only(false));
@@ -1078,6 +1189,12 @@ 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,11 +1,10 @@
 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, ForegroundExecutor, Subscription,
-    Task,
-};
+use gpui::{Action, AnyElement, App, BackgroundExecutor, DismissEvent, Subscription, Task};
 use language_model::{
    AuthenticateError, ConfiguredModel, LanguageModel, LanguageModelProviderId,
    LanguageModelRegistry,
@@ -14,6 +13,8 @@ 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>;

@@ -278,28 +279,22 @@ enum LanguageModelPickerEntry {

 struct ModelMatcher {
    models: Vec<ModelInfo>,
-    fg_executor: ForegroundExecutor,
    bg_executor: BackgroundExecutor,
    candidates: Vec<StringMatchCandidate>,
 }

 impl ModelMatcher {
-    fn new(
-        models: Vec<ModelInfo>,
-        fg_executor: ForegroundExecutor,
-        bg_executor: BackgroundExecutor,
-    ) -> ModelMatcher {
+    fn new(models: Vec<ModelInfo>, bg_executor: BackgroundExecutor) -> ModelMatcher {
        let candidates = Self::make_match_candidates(&models);
        Self {
            models,
-            fg_executor,
            bg_executor,
            candidates,
        }
    }

    pub fn fuzzy_search(&self, query: &str) -> Vec<ModelInfo> {
-        let mut matches = self.fg_executor.block_on(match_strings(
+        let mut matches = self.bg_executor.block(match_strings(
            &self.candidates,
            query,
            false,
@@ -395,7 +390,6 @@ impl PickerDelegate for LanguageModelPickerDelegate {
    ) -> Task<()> {
        let all_models = self.all_models.clone();
        let active_model = (self.get_active_model)(cx);
-        let fg_executor = cx.foreground_executor();
        let bg_executor = cx.background_executor();

        let language_model_registry = LanguageModelRegistry::global(cx);
@@ -426,10 +420,8 @@ impl PickerDelegate for LanguageModelPickerDelegate {
            .cloned()
            .collect::<Vec<_>>();

-        let matcher_rec =
-            ModelMatcher::new(recommended_models, fg_executor.clone(), bg_executor.clone());
-        let matcher_all =
-            ModelMatcher::new(available_models, fg_executor.clone(), bg_executor.clone());
+        let matcher_rec = ModelMatcher::new(recommended_models, bg_executor.clone());
+        let matcher_all = ModelMatcher::new(available_models, bg_executor.clone());

        let recommended = matcher_rec.exact_search(&query);
        let all = matcher_all.fuzzy_search(&query);
@@ -539,9 +531,13 @@ impl PickerDelegate for LanguageModelPickerDelegate {

    fn render_footer(
        &self,
-        _window: &mut Window,
+        _: &mut Window,
        cx: &mut Context<Picker<Self>>,
    ) -> Option<gpui::AnyElement> {
+        use feature_flags::FeatureFlagAppExt;
+
+        let plan = Plan::ZedPro;
+
        Some(
            h_flex()
                .w_full()
@@ -550,6 +546,28 @@ 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)
@@ -702,7 +720,7 @@ mod tests {
            ("ollama", "mistral"),
            ("ollama", "deepseek"),
        ]);
-        let matcher = ModelMatcher::new(models, cx.foreground_executor(), cx.executor());
+        let matcher = ModelMatcher::new(models, cx.background_executor.clone());

        // The order of models should be maintained, case doesn't matter
        let results = matcher.exact_search("GPT-4.1");
@@ -730,7 +748,7 @@ mod tests {
            ("ollama", "mistral"),
            ("ollama", "deepseek"),
        ]);
-        let matcher = ModelMatcher::new(models, cx.foreground_executor(), cx.executor());
+        let matcher = ModelMatcher::new(models, cx.background_executor.clone());

        // Results should preserve models order whenever possible.
        // In the case below, `zed/gpt-4.1` and `openai/gpt-4.1` have identical
--- a/crates/agent_ui/src/message_editor.rs
+++ b/crates/agent_ui/src/message_editor.rs
@@ -125,7 +125,6 @@ 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, TintColor,
-    Tooltip, prelude::*,
+    ContextMenu, ContextMenuEntry, DocumentationSide, PopoverMenu, PopoverMenuHandle, Tooltip,
+    prelude::*,
 };

 /// Trait for types that can provide and manage agent profiles
@@ -170,8 +170,7 @@ impl Render for ProfileSelector {
                .icon(IconName::ChevronDown)
                .icon_size(IconSize::XSmall)
                .icon_position(IconPosition::End)
-                .icon_color(Color::Muted)
-                .selected_style(ButtonStyle::Tinted(TintColor::Accent));
+                .icon_color(Color::Muted);

            PopoverMenu::new("profile-selector")
                .trigger_with_tooltip(trigger_button, {
@@ -196,10 +195,6 @@ 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,11 +2,10 @@ use anyhow::Result;
 use gpui::App;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsKey, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsSources, SettingsUi};

 /// Settings for slash commands.
-#[derive(Deserialize, Serialize, Debug, Default, Clone, JsonSchema, SettingsUi, SettingsKey)]
-#[settings_key(key = "slash_commands")]
+#[derive(Deserialize, Serialize, Debug, Default, Clone, JsonSchema, SettingsUi)]
 pub struct SlashCommandSettings {
    /// Settings for the `/cargo-workspace` slash command.
    #[serde(default)]
@@ -22,6 +21,8 @@ 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,7 +2,6 @@ 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::*};

@@ -19,6 +18,8 @@ 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(
@@ -32,7 +33,7 @@ impl RenderOnce for EndTrialUpsell {
                    )
                    .child(Divider::horizontal()),
            )
-            .child(PlanDefinitions.pro_plan(cx.has_flag::<BillingV2FeatureFlag>(), false))
+            .child(plan_definitions.pro_plan(false))
            .child(
                Button::new("cta-button", "Upgrade to Zed Pro")
                    .full_width()
@@ -63,7 +64,7 @@ impl RenderOnce for EndTrialUpsell {
                    )
                    .child(Divider::horizontal()),
            )
-            .child(PlanDefinitions.free_plan(cx.has_flag::<BillingV2FeatureFlag>()));
+            .child(plan_definitions.free_plan());

        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::ZedProTrialV2 => (
+                Plan::ZedProTrial => (
                    "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::ZedProV2 => (
+                Plan::ZedPro => (
                    "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,7 +18,6 @@ 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,7 +18,6 @@ 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::*};

@@ -85,8 +84,9 @@ 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(PlanDefinitions.pro_plan(cx.has_flag::<BillingV2FeatureFlag>(), false))
+            .child(plan_definitions.pro_plan(false))
            .child(
                Button::new("sign_in", "Try Zed Pro for Free")
                    .disabled(signing_in)
@@ -114,13 +114,16 @@ 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(YoungAccountBanner)
+                .child(young_account_banner)
                .child(
                    v_flex()
                        .mt_2()
@@ -136,9 +139,7 @@ impl ZedAiOnboarding {
                                )
                                .child(Divider::horizontal()),
                        )
-                        .child(
-                            PlanDefinitions.pro_plan(cx.has_flag::<BillingV2FeatureFlag>(), true),
-                        )
+                        .child(plan_definitions.pro_plan(true))
                        .child(
                            Button::new("pro", "Get Started")
                                .full_width()
@@ -181,7 +182,7 @@ impl ZedAiOnboarding {
                                )
                                .child(Divider::horizontal()),
                        )
-                        .child(PlanDefinitions.free_plan(cx.has_flag::<BillingV2FeatureFlag>())),
+                        .child(plan_definitions.free_plan()),
                )
                .when_some(
                    self.dismiss_onboarding.as_ref(),
@@ -219,9 +220,7 @@ impl ZedAiOnboarding {
                                )
                                .child(Divider::horizontal()),
                        )
-                        .child(
-                            PlanDefinitions.pro_trial(cx.has_flag::<BillingV2FeatureFlag>(), true),
-                        )
+                        .child(plan_definitions.pro_trial(true))
                        .child(
                            Button::new("pro", "Start Free Trial")
                                .full_width()
@@ -239,7 +238,9 @@ impl ZedAiOnboarding {
        }
    }

-    fn render_trial_state(&self, is_v2: bool, _cx: &mut App) -> AnyElement {
+    fn render_trial_state(&self, _cx: &mut App) -> AnyElement {
+        let plan_definitions = PlanDefinitions;
+
        v_flex()
            .relative()
            .gap_1()
@@ -249,7 +250,7 @@ impl ZedAiOnboarding {
                    .color(Color::Muted)
                    .mb_2(),
            )
-            .child(PlanDefinitions.pro_trial(is_v2, false))
+            .child(plan_definitions.pro_trial(false))
            .when_some(
                self.dismiss_onboarding.as_ref(),
                |this, dismiss_callback| {
@@ -273,7 +274,9 @@ impl ZedAiOnboarding {
            .into_any_element()
    }

-    fn render_pro_plan_state(&self, is_v2: bool, _cx: &mut App) -> AnyElement {
+    fn render_pro_plan_state(&self, _cx: &mut App) -> AnyElement {
+        let plan_definitions = PlanDefinitions;
+
        v_flex()
            .gap_1()
            .child(Headline::new("Welcome to Zed Pro"))
@@ -282,7 +285,7 @@ impl ZedAiOnboarding {
                    .color(Color::Muted)
                    .mb_2(),
            )
-            .child(PlanDefinitions.pro_plan(is_v2, false))
+            .child(plan_definitions.pro_plan(false))
            .when_some(
                self.dismiss_onboarding.as_ref(),
                |this, dismiss_callback| {
@@ -312,10 +315,8 @@ 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(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),
+                Some(Plan::ZedProTrial) => self.render_trial_state(cx),
+                Some(Plan::ZedPro) => self.render_pro_plan_state(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,7 +2,6 @@ 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::*};

@@ -50,6 +49,9 @@ 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()
@@ -65,7 +67,7 @@ impl RenderOnce for AiUpsellCard {
                    )
                    .child(Divider::horizontal()),
            )
-            .child(PlanDefinitions.pro_plan(cx.has_flag::<BillingV2FeatureFlag>(), false));
+            .child(plan_definitions.pro_plan(false));

        let free_section = v_flex()
            .flex_grow()
@@ -82,7 +84,7 @@ impl RenderOnce for AiUpsellCard {
                    )
                    .child(Divider::horizontal()),
            )
-            .child(PlanDefinitions.free_plan(cx.has_flag::<BillingV2FeatureFlag>()));
+            .child(plan_definitions.free_plan());

        let grid_bg = h_flex()
            .absolute()
@@ -171,7 +173,7 @@ impl RenderOnce for AiUpsellCard {
                    .child(Label::new("Try Zed AI").size(LabelSize::Large))
                    .map(|this| {
                        if self.account_too_young {
-                            this.child(YoungAccountBanner).child(
+                            this.child(young_account_banner).child(
                                v_flex()
                                    .mt_2()
                                    .gap_1()
@@ -186,10 +188,7 @@ impl RenderOnce for AiUpsellCard {
                                            )
                                            .child(Divider::horizontal()),
                                    )
-                                    .child(
-                                        PlanDefinitions
-                                            .pro_plan(cx.has_flag::<BillingV2FeatureFlag>(), true),
-                                    )
+                                    .child(plan_definitions.pro_plan(true))
                                    .child(
                                        Button::new("pro", "Get Started")
                                            .full_width()
@@ -236,7 +235,7 @@ impl RenderOnce for AiUpsellCard {
                            )
                        }
                    }),
-                Some(plan @ Plan::ZedProTrial | plan @ Plan::ZedProTrialV2) => card
+                Some(Plan::ZedProTrial) => card
                    .child(pro_trial_stamp)
                    .child(Label::new("You're in the Zed Pro Trial").size(LabelSize::Large))
                    .child(
@@ -244,8 +243,8 @@ impl RenderOnce for AiUpsellCard {
                            .color(Color::Muted)
                            .mb_2(),
                    )
-                    .child(PlanDefinitions.pro_trial(plan == Plan::ZedProTrialV2, false)),
-                Some(plan @ Plan::ZedPro | plan @ Plan::ZedProV2) => card
+                    .child(plan_definitions.pro_trial(false)),
+                Some(Plan::ZedPro) => card
                    .child(certified_user_stamp)
                    .child(Label::new("You're in the Zed Pro plan").size(LabelSize::Large))
                    .child(
@@ -253,7 +252,7 @@ impl RenderOnce for AiUpsellCard {
                            .color(Color::Muted)
                            .mb_2(),
                    )
-                    .child(PlanDefinitions.pro_plan(plan == Plan::ZedProV2, false)),
+                    .child(plan_definitions.pro_plan(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, _is_v2: bool) -> impl IntoElement {
+    pub fn free_plan(&self) -> 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, _is_v2: bool, period: bool) -> impl IntoElement {
+    pub fn pro_trial(&self, 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, _is_v2: bool, price: bool) -> impl IntoElement {
+    pub fn pro_plan(&self, 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.random_range(min_peers..=max_peers);
+    let num_peers = rng.gen_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.random_range(0..contexts.len());
+        let context_index = rng.gen_range(0..contexts.len());
        let context = &contexts[context_index];

-        match rng.random_range(0..100) {
+        match rng.gen_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.random_range(0..=3);
+                    let num_sections = rng.gen_range(0..=3);
                    let mut section_start = 0;
                    for _ in 0..num_sections {
-                        let mut section_end = rng.random_range(section_start..=output_text.len());
+                        let mut section_end = rng.gen_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.random_range(0..3) {
+                        let new_status = match rng.gen_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.random_bool(0.1) && replica_id != 0 {
+                } else if rng.gen_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.random_range(1..=100);
+        let len = rng.gen_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.random_range(0..=8)), line))
+            .map(|line| format!("{}{}", " ".repeat(rng.gen_range(0..=8)), line))
            .collect::<Vec<_>>()
            .join("\n");
-        let delta = IndentDelta::Spaces(rng.random_range(-4i8..=4i8) as isize);
+        let delta = IndentDelta::Spaces(rng.gen_range(-4..=4));

        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.random_range(1..=cmp::min(input.len(), 50));
+        let chunk_count = rng.gen_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.random_range(1..=cmp::min(input.len(), 50));
+        let chunk_count = rng.gen_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.random_range(1..=cmp::min(input.len(), 50));
+        let chunk_count = rng.gen_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
@@ -11,7 +11,7 @@ use client::{Client, UserStore};
 use collections::HashMap;
 use fs::FakeFs;
 use futures::{FutureExt, future::LocalBoxFuture};
-use gpui::{AppContext, TestAppContext, TestScheduler, TestSchedulerConfig, Timer};
+use gpui::{AppContext, TestAppContext, Timer};
 use http_client::StatusCode;
 use indoc::{formatdoc, indoc};
 use language_model::{
@@ -1399,9 +1399,9 @@ fn eval(
 }

 fn run_eval(eval: EvalInput, tx: mpsc::Sender<Result<EvalOutput>>) {
-    let scheduler = Arc::new(TestScheduler::new(TestSchedulerConfig::default()));
-    let mut cx = TestAppContext::build(scheduler, None);
-    let output = cx.foreground_executor().block_on(async {
+    let dispatcher = gpui::TestDispatcher::new(StdRng::from_entropy());
+    let mut cx = TestAppContext::build(dispatcher, None);
+    let output = cx.executor().block_test(async {
        let test = EditAgentTest::new(&mut cx).await;
        test.eval(eval, &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::rng().random_range(0.0..1.0));
+            let jitter = retry_after.mul_f64(rand::thread_rng().gen_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.random_range(1..=cmp::min(input.len(), 50));
+        let chunk_count = rng.gen_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, SettingsKey, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsSources, SettingsUi};

-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
 pub struct AudioSettings {
    /// Opt into the new audio system.
    #[serde(rename = "experimental.rodio_audio", default)]
@@ -12,9 +12,8 @@ pub struct AudioSettings {
 }

 /// Configuration of audio in Zed.
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi, SettingsKey)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi)]
 #[serde(default)]
-#[settings_key(key = "audio")]
 pub struct AudioSettingsContent {
    /// Whether to use the experimental audio system
    #[serde(rename = "experimental.rodio_audio", default)]
@@ -22,6 +21,8 @@ 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, SettingsKey, SettingsSources, SettingsStore, SettingsUi};
+use settings::{Settings, SettingsSources, SettingsStore, SettingsUi};
 use smol::{fs, io::AsyncReadExt};
 use smol::{fs::File, process::Command};
 use std::{
@@ -118,12 +118,13 @@ struct AutoUpdateSetting(bool);
 /// Whether or not to automatically check for updates.
 ///
 /// Default: true
-#[derive(Clone, Copy, Default, JsonSchema, Deserialize, Serialize, SettingsUi, SettingsKey)]
+#[derive(Clone, Copy, Default, JsonSchema, Deserialize, Serialize, SettingsUi)]
 #[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,4 +1,5 @@
 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;
@@ -87,7 +88,10 @@ fn view_release_notes_locally(
                        .update_in(cx, |workspace, window, cx| {
                            let project = workspace.project().clone();
                            let buffer = project.update(cx, |project, cx| {
-                                project.create_local_buffer("", markdown, false, cx)
+                                let buffer = project.create_local_buffer("", markdown, cx);
+                                project
+                                    .mark_buffer_as_non_searchable(buffer.read(cx).remote_id(), cx);
+                                buffer
                            });
                            buffer.update(cx, |buffer, cx| {
                                buffer.edit([(0..0, body.release_notes)], None, cx)
@@ -137,8 +141,6 @@ 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
@@ -1,13 +1,21 @@
 use futures::channel::oneshot;
 use git2::{DiffLineType as GitDiffLineType, DiffOptions as GitOptions, Patch as GitPatch};
-use gpui::{App, AppContext as _, AsyncApp, Context, Entity, EventEmitter, Task};
+use gpui::{App, AppContext as _, AsyncApp, Context, Entity, EventEmitter, Task, TaskLabel};
 use language::{Language, LanguageRegistry};
 use rope::Rope;
-use std::{cmp::Ordering, future::Future, iter, ops::Range, sync::Arc};
+use std::{
+    cmp::Ordering,
+    future::Future,
+    iter,
+    ops::Range,
+    sync::{Arc, LazyLock},
+};
 use sum_tree::SumTree;
 use text::{Anchor, Bias, BufferId, OffsetRangeExt, Point, ToOffset as _};
 use util::ResultExt;

+pub static CALCULATE_DIFF_TASK: LazyLock<TaskLabel> = LazyLock::new(TaskLabel::new);
+
 pub struct BufferDiff {
    pub buffer_id: BufferId,
    inner: BufferDiffInner,
@@ -193,10 +201,12 @@ impl BufferDiffSnapshot {
            base_text_exists = false;
        };

-        let hunks = cx.background_executor().spawn({
-            let buffer = buffer.clone();
-            async move { compute_hunks(base_text_pair, buffer) }
-        });
+        let hunks = cx
+            .background_executor()
+            .spawn_labeled(*CALCULATE_DIFF_TASK, {
+                let buffer = buffer.clone();
+                async move { compute_hunks(base_text_pair, buffer) }
+            });

        async move {
            let (base_text, hunks) = futures::join!(base_text_snapshot, hunks);
@@ -223,17 +233,18 @@ impl BufferDiffSnapshot {
            debug_assert_eq!(&*text, &base_text_snapshot.text());
            (text, base_text_snapshot.as_rope().clone())
        });
-        cx.background_executor().spawn(async move {
-            Self {
-                inner: BufferDiffInner {
-                    base_text: base_text_snapshot,
-                    pending_hunks: SumTree::new(&buffer),
-                    hunks: compute_hunks(base_text_pair, buffer),
-                    base_text_exists,
-                },
-                secondary_diff: None,
-            }
-        })
+        cx.background_executor()
+            .spawn_labeled(*CALCULATE_DIFF_TASK, async move {
+                Self {
+                    inner: BufferDiffInner {
+                        base_text: base_text_snapshot,
+                        pending_hunks: SumTree::new(&buffer),
+                        hunks: compute_hunks(base_text_pair, buffer),
+                        base_text_exists,
+                    },
+                    secondary_diff: None,
+                }
+            })
    }

    #[cfg(test)]
@@ -242,7 +253,7 @@ impl BufferDiffSnapshot {
        diff_base: String,
        cx: &mut gpui::TestAppContext,
    ) -> BufferDiffSnapshot {
-        cx.foreground_executor().block_on(cx.update(|cx| {
+        cx.executor().block(cx.update(|cx| {
            Self::new_with_base_text(buffer, Some(Arc::new(diff_base)), None, None, cx)
        }))
    }
@@ -908,7 +919,7 @@ impl BufferDiff {
            None,
            cx,
        );
-        let snapshot = cx.foreground_executor().block_on(snapshot);
+        let snapshot = cx.background_executor().block(snapshot);
        Self {
            buffer_id: buffer.read(cx).remote_id(),
            inner: snapshot.inner,
@@ -1211,7 +1222,7 @@ impl BufferDiff {
            self.inner.base_text.clone(),
            cx,
        );
-        let snapshot = cx.foreground_executor().block_on(snapshot);
+        let snapshot = cx.background_executor().block(snapshot);
        self.set_snapshot(snapshot, &buffer, cx);
    }
 }
@@ -2033,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.random_bool(0.2) {
+            if rng.gen_bool(0.2) {
                "\n".to_owned()
            } else {
-                let c = rng.random_range('A'..='Z');
+                let c = rng.gen_range('A'..='Z');
                format!("{c}{c}{c}\n")
            }
        }
@@ -2055,7 +2066,7 @@ mod tests {
                old_lines.into_iter()
            };
            let mut result = String::new();
-            let unchanged_count = rng.random_range(0..=old_lines.len());
+            let unchanged_count = rng.gen_range(0..=old_lines.len());
            result +=
                &old_lines
                    .by_ref()
@@ -2065,14 +2076,14 @@ mod tests {
                        s
                    });
            while old_lines.len() > 0 {
-                let deleted_count = rng.random_range(0..=old_lines.len());
+                let deleted_count = rng.gen_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.random_range(minimum_added..=5);
+                let added_count = rng.gen_range(minimum_added..=5);
                let addition = (0..added_count).map(|_| gen_line(rng)).collect::<String>();
                result += &addition;

@@ -2081,8 +2092,7 @@ mod tests {
                    if blank_lines == old_lines.len() {
                        break;
                    };
-                    let unchanged_count =
-                        rng.random_range((blank_lines + 1).max(1)..=old_lines.len());
+                    let unchanged_count = rng.gen_range((blank_lines + 1).max(1)..=old_lines.len());
                    result += &old_lines.by_ref().take(unchanged_count).fold(
                        String::new(),
                        |mut s, line| {
@@ -2139,7 +2149,7 @@ mod tests {
            )
        });
        let working_copy = working_copy.read_with(cx, |working_copy, _| working_copy.snapshot());
-        let mut index_text = if rng.random() {
+        let mut index_text = if rng.r#gen() {
            Rope::from(head_text.as_str())
        } else {
            working_copy.as_rope().clone()
@@ -2155,7 +2165,7 @@ mod tests {
        }

        for _ in 0..operations {
-            let i = rng.random_range(0..hunks.len());
+            let i = rng.gen_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, SettingsKey, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsSources, SettingsUi};

 #[derive(Deserialize, Debug)]
 pub struct CallSettings {
@@ -11,8 +11,7 @@ pub struct CallSettings {
 }

 /// Configuration of voice calls in Zed.
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi, SettingsKey)]
-#[settings_key(key = "calls")]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug, SettingsUi)]
 pub struct CallSettingsContent {
    /// Whether the microphone should be muted when joining a channel or a call.
    ///
@@ -26,6 +25,8 @@ 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,9 +25,11 @@ 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,4 +1,5 @@
 mod channel_buffer;
+mod channel_chat;
 mod channel_store;

 use client::{Client, UserStore};
@@ -6,6 +7,10 @@ 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)]
@@ -14,4 +19,5 @@ 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
@@ -0,0 +1,861 @@
+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::channel_buffer::ChannelBuffer;
+use crate::{ChannelMessage, channel_buffer::ChannelBuffer, channel_chat::ChannelChat};
 use anyhow::{Context as _, Result, anyhow};
 use channel_index::ChannelIndex;
 use client::{ChannelId, Client, ClientSettings, Subscription, User, UserId, UserStore};
@@ -41,6 +41,7 @@ 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>),
@@ -62,8 +63,10 @@ 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>,
 }

@@ -193,6 +196,7 @@ impl ChannelStore {
            channel_participants: Default::default(),
            outgoing_invites: Default::default(),
            opened_buffers: Default::default(),
+            opened_chats: Default::default(),
            update_channels_tx,
            client,
            user_store,
@@ -358,12 +362,89 @@ 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,
@@ -392,6 +473,23 @@ 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
@@ -833,6 +931,13 @@ 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
@@ -852,6 +957,16 @@ 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
@@ -979,6 +1094,7 @@ 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();
    }
@@ -1015,6 +1131,7 @@ 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 {
@@ -1064,6 +1181,13 @@ 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();
        }

@@ -1127,6 +1251,29 @@ 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,7 +1,9 @@
+use crate::channel_chat::ChannelChatEvent;
+
 use super::*;
-use client::{Client, UserStore};
+use client::{Client, UserStore, test::FakeServer};
 use clock::FakeSystemClock;
-use gpui::{App, AppContext as _, Entity, SemanticVersion};
+use gpui::{App, AppContext as _, Entity, SemanticVersion, TestAppContext};
 use http_client::FakeHttpClient;
 use rpc::proto::{self};
 use settings::SettingsStore;
@@ -233,6 +235,201 @@ 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]
-objc2-foundation.workspace = true
+cocoa.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, SettingsKey, SettingsSources, SettingsUi};
+use settings::{Settings, SettingsSources, SettingsUi};
 use std::{
    any::TypeId,
    convert::TryFrom,
@@ -96,8 +96,7 @@ actions!(
    ]
 );

-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey)]
-#[settings_key(None)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, SettingsUi)]
 pub struct ClientSettingsContent {
    server_url: Option<String>,
 }
@@ -108,6 +107,8 @@ 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> {
@@ -121,8 +122,7 @@ impl Settings for ClientSettings {
    fn import_from_vscode(_vscode: &settings::VsCodeSettings, _current: &mut Self::FileContent) {}
 }

-#[derive(Default, Clone, Serialize, Deserialize, JsonSchema, SettingsUi, SettingsKey)]
-#[settings_key(None)]
+#[derive(Default, Clone, Serialize, Deserialize, JsonSchema, SettingsUi)]
 pub struct ProxySettingsContent {
    proxy: Option<String>,
 }
@@ -133,6 +133,8 @@ 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> {
@@ -525,8 +527,7 @@ pub struct TelemetrySettings {
 }

 /// Control what info is collected by Zed.
-#[derive(Default, Clone, Serialize, Deserialize, JsonSchema, Debug, SettingsUi, SettingsKey)]
-#[settings_key(key = "telemetry")]
+#[derive(Default, Clone, Serialize, Deserialize, JsonSchema, Debug, SettingsUi)]
 pub struct TelemetrySettingsContent {
    /// Send debug info like crash reports.
    ///
@@ -539,6 +540,8 @@ 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> {
@@ -688,7 +691,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_os_rng();
+                    let mut rng = StdRng::from_entropy();

                    let mut delay = INITIAL_RECONNECTION_DELAY;
                    loop {
@@ -718,9 +721,8 @@ impl Client {
                                },
                                cx,
                            );
-                            let jitter = Duration::from_millis(
-                                rng.random_range(0..delay.as_millis() as u64),
-                            );
+                            let jitter =
+                                Duration::from_millis(rng.gen_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,10 +84,6 @@ 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")]
    {
@@ -112,16 +108,19 @@ pub fn os_name() -> String {
 pub fn os_version() -> String {
    #[cfg(target_os = "macos")]
    {
-        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, "")
+        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,
+            )
            .to_string()
+        }
    }
    #[cfg(any(target_os = "linux", target_os = "freebsd"))]
    {
--- a/crates/client/src/test.rs
+++ b/crates/client/src/test.rs
@@ -3,7 +3,7 @@ use anyhow::{Context as _, Result, anyhow};
 use cloud_api_client::{AuthenticatedUser, GetAuthenticatedUserResponse, PlanInfo};
 use cloud_llm_client::{CurrentUsage, Plan, UsageData, UsageLimit};
 use futures::{StreamExt, stream::BoxStream};
-use gpui::{AppContext as _, Entity, TestAppContext};
+use gpui::{AppContext as _, BackgroundExecutor, Entity, TestAppContext};
 use http_client::{AsyncBody, Method, Request, http};
 use parking_lot::Mutex;
 use rpc::{ConnectionId, Peer, Receipt, TypedEnvelope, proto};
@@ -13,6 +13,7 @@ pub struct FakeServer {
    peer: Arc<Peer>,
    state: Arc<Mutex<FakeServerState>>,
    user_id: u64,
+    executor: BackgroundExecutor,
 }

 #[derive(Default)]
@@ -34,6 +35,7 @@ impl FakeServer {
            peer: Peer::new(0),
            state: Default::default(),
            user_id: client_user_id,
+            executor: cx.executor(),
        };

        client.http_client().as_fake().replace_handler({
@@ -179,6 +181,8 @@ impl FakeServer {

    #[allow(clippy::await_holding_lock)]
    pub async fn receive<M: proto::EnvelopedMessage>(&self) -> Result<TypedEnvelope<M>> {
+        self.executor.start_waiting();
+
        let message = self
            .state
            .lock()
@@ -188,6 +192,7 @@ impl FakeServer {
            .next()
            .await
            .context("other half hung up")?;
+        self.executor.finish_waiting();
        let type_name = message.payload_type_name();
        let message = message.into_any();

--- a/crates/cloud_llm_client/src/cloud_llm_client.rs
+++ b/crates/cloud_llm_client/src/cloud_llm_client.rs
@@ -82,10 +82,34 @@ pub enum Plan {
    ZedFree,
    #[serde(alias = "ZedPro")]
    ZedPro,
-    ZedProV2,
    #[serde(alias = "ZedProTrial")]
    ZedProTrial,
-    ZedProTrialV2,
+}
+
+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),
+        }
+    }
 }

 impl FromStr for Plan {
@@ -329,12 +353,6 @@ 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::prelude::*;
+    use rand::thread_rng;
    use scrypt::password_hash::{PasswordHasher, SaltString};
    use sea_orm::EntityTrait;

@@ -358,42 +358,9 @@ mod test {
                None,
                None,
                params,
-                &SaltString::generate(PasswordHashRngCompat::new()),
+                &SaltString::generate(thread_rng()),
            )
            .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,6 +26,7 @@ use semantic_version::SemanticVersion;
 use serde::{Deserialize, Serialize};
 use std::ops::RangeInclusive;
 use std::{
+    fmt::Write as _,
    future::Future,
    marker::PhantomData,
    ops::{Deref, DerefMut},
@@ -255,7 +256,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().random_bool(fail_probability) {
+            if test_options.executor.rng().gen_bool(fail_probability) {
                return Err(anyhow!("simulated query failure"))?;
            }

@@ -485,7 +486,9 @@ 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,6 +7,7 @@ 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,17 +618,25 @@ 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
@@ -0,0 +1,725 @@
+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,6 +1193,7 @@ 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/Show More
+++ b/Show More
Author	SHA1	Message	Date
Mikayla Maki	a46eb6737c	make it remove old paths	2025-09-03 21:55:09 -07:00
Mikayla Maki	d80fa82009	Write to the user settings file when changing language with the selector	2025-09-03 21:43:47 -07:00