while await

it opens fast
await
2025-04-17 20:25:41 +05:30 · 2025-04-17 20:11:38 +05:30 · 2025-04-17 19:57:52 +05:30 · 2025-04-17 18:55:24 +05:30 · 2025-04-16 22:31:04 -06:00 · 2025-04-16 21:57:42 -06:00
132 changed files with 4336 additions and 1380 deletions
--- a/.github/workflows/run_agent_eval_daily.yml
+++ b/.github/workflows/run_agent_eval_daily.yml
@@ -0,0 +1,28 @@
+name: Run Eval Daily
+
+on:
+  schedule:
+    - cron: "0 2 * * *"
+  workflow_dispatch:
+
+env:
+  CARGO_TERM_COLOR: always
+  CARGO_INCREMENTAL: 0
+  RUST_BACKTRACE: 1
+
+jobs:
+  run_eval:
+    name: Run Eval
+    if: github.repository_owner == 'zed-industries'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        with:
+          clean: false
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Run cargo eval
+        run: cargo run -p eval
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -324,7 +324,7 @@ dependencies = [
 "schemars",
 "serde",
 "serde_json",
- "strum",
+ "strum 0.27.1",
 "thiserror 2.0.12",
 "workspace-hack",
 ]
@@ -337,9 +337,9 @@ checksum = "34cd60c5e3152cef0a592f1b296f1cc93715d89d2551d85315828c3a09575ff4"

 [[package]]
 name = "anyhow"
-version = "1.0.97"
+version = "1.0.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f"
+checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"

 [[package]]
 name = "approx"
@@ -448,7 +448,6 @@ dependencies = [
 "smol",
 "tempfile",
 "util",
- "which 6.0.3",
 "workspace-hack",
 ]

@@ -567,7 +566,7 @@ dependencies = [
 "settings",
 "smallvec",
 "smol",
- "strum",
+ "strum 0.27.1",
 "telemetry_events",
 "text",
 "theme",
@@ -704,6 +703,7 @@ dependencies = [
 "assistant_tool",
 "chrono",
 "collections",
+ "feature_flags",
 "futures 0.3.31",
 "gpui",
 "html_to_markdown",
@@ -721,9 +721,11 @@ dependencies = [
 "ui",
 "unindent",
 "util",
+ "web_search",
 "workspace",
 "workspace-hack",
 "worktree",
+ "zed_llm_client",
 ]

 [[package]]
@@ -1881,7 +1883,7 @@ dependencies = [
 "schemars",
 "serde",
 "serde_json",
- "strum",
+ "strum 0.27.1",
 "thiserror 2.0.12",
 "tokio",
 "workspace-hack",
@@ -3028,7 +3030,7 @@ dependencies = [
 "settings",
 "sha2",
 "sqlx",
- "strum",
+ "strum 0.27.1",
 "subtle",
 "supermaven_api",
 "telemetry_events",
@@ -3048,6 +3050,7 @@ dependencies = [
 "workspace",
 "workspace-hack",
 "worktree",
+ "zed_llm_client",
 ]

 [[package]]
@@ -3360,7 +3363,7 @@ dependencies = [
 "serde",
 "serde_json",
 "settings",
- "strum",
+ "strum 0.27.1",
 "task",
 "theme",
 "ui",
@@ -4477,7 +4480,7 @@ dependencies = [
 "optfield",
 "proc-macro2",
 "quote",
- "strum",
+ "strum 0.26.3",
 "syn 2.0.100",
 ]

@@ -4886,6 +4889,7 @@ dependencies = [
 "collections",
 "context_server",
 "dap",
+ "dirs 5.0.1",
 "env_logger 0.11.8",
 "extension",
 "fs",
@@ -4907,9 +4911,11 @@ dependencies = [
 "serde",
 "settings",
 "shellexpand 2.1.2",
+ "telemetry",
 "toml 0.8.20",
 "unindent",
 "util",
+ "uuid",
 "workspace-hack",
 ]

@@ -5119,7 +5125,7 @@ dependencies = [
 "serde",
 "settings",
 "smallvec",
- "strum",
+ "strum 0.27.1",
 "telemetry",
 "theme",
 "ui",
@@ -5970,7 +5976,7 @@ dependencies = [
 "serde_derive",
 "serde_json",
 "settings",
- "strum",
+ "strum 0.27.1",
 "telemetry",
 "theme",
 "time",
@@ -6063,7 +6069,7 @@ dependencies = [
 "schemars",
 "serde",
 "serde_json",
- "strum",
+ "strum 0.27.1",
 "workspace-hack",
 ]

@@ -6169,7 +6175,7 @@ dependencies = [
 "slotmap",
 "smallvec",
 "smol",
- "strum",
+ "strum 0.27.1",
 "sum_tree",
 "taffy",
 "thiserror 2.0.12",
@@ -6817,7 +6823,7 @@ name = "icons"
 version = "0.1.0"
 dependencies = [
 "serde",
- "strum",
+ "strum 0.27.1",
 "workspace-hack",
 ]

@@ -7085,16 +7091,16 @@ dependencies = [
 "paths",
 "pretty_assertions",
 "serde",
- "strum",
+ "strum 0.27.1",
 "util",
 "workspace-hack",
 ]

 [[package]]
 name = "indexmap"
-version = "2.9.0"
+version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e"
+checksum = "3954d50fe15b02142bf25d3b8bdadb634ec3948f103d04ffe3031bc8fe9d7058"
 dependencies = [
 "equivalent",
 "hashbrown 0.15.2",
@@ -7671,7 +7677,7 @@ dependencies = [
 "serde",
 "serde_json",
 "smol",
- "strum",
+ "strum 0.27.1",
 "telemetry_events",
 "thiserror 2.0.12",
 "util",
@@ -7731,7 +7737,7 @@ dependencies = [
 "serde_json",
 "settings",
 "smol",
- "strum",
+ "strum 0.27.1",
 "theme",
 "thiserror 2.0.12",
 "tiktoken-rs",
@@ -7739,6 +7745,7 @@ dependencies = [
 "ui",
 "util",
 "workspace-hack",
+ "zed_llm_client",
 ]

 [[package]]
@@ -7954,9 +7961,9 @@ checksum = "8355be11b20d696c8f18f6cc018c4e372165b1fa8126cef092399c9951984ffa"

 [[package]]
 name = "libmimalloc-sys"
-version = "0.1.42"
+version = "0.1.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec9d6fac27761dabcd4ee73571cdb06b7022dc99089acbe5435691edffaac0f4"
+checksum = "6b20daca3a4ac14dbdc753c5e90fc7b490a48a9131daed3c9a9ced7b2defd37b"
 dependencies = [
 "cc",
 "libc",
@@ -8627,9 +8634,9 @@ dependencies = [

 [[package]]
 name = "mimalloc"
-version = "0.1.46"
+version = "0.1.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "995942f432bbb4822a7e9c3faa87a695185b0d09273ba85f097b54f4e458f2af"
+checksum = "03cb1f88093fe50061ca1195d336ffec131347c7b833db31f9ab62a2d1b7925f"
 dependencies = [
 "libmimalloc-sys",
 ]
@@ -8703,7 +8710,7 @@ dependencies = [
 "schemars",
 "serde",
 "serde_json",
- "strum",
+ "strum 0.27.1",
 "workspace-hack",
 ]

@@ -9550,7 +9557,7 @@ dependencies = [
 "schemars",
 "serde",
 "serde_json",
- "strum",
+ "strum 0.27.1",
 "workspace-hack",
 ]

@@ -11744,6 +11751,7 @@ name = "remote_server"
 version = "0.1.0"
 dependencies = [
 "anyhow",
+ "askpass",
 "async-watch",
 "backtrace",
 "cargo_toml",
@@ -12129,7 +12137,7 @@ dependencies = [
 "serde",
 "serde_json",
 "sha2",
- "strum",
+ "strum 0.27.1",
 "tracing",
 "util",
 "workspace-hack",
@@ -12657,7 +12665,7 @@ dependencies = [
 "serde",
 "serde_json",
 "sqlx",
- "strum",
+ "strum 0.26.3",
 "thiserror 2.0.12",
 "time",
 "tracing",
@@ -13253,9 +13261,9 @@ dependencies = [

 [[package]]
 name = "smallvec"
-version = "1.15.0"
+version = "1.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8917285742e9f3e1683f0a9c4e6b57960b7314d0b08d30d1ecd426713ee2eee9"
+checksum = "7fcf8323ef1faaee30a44a340193b1ac6814fd9b7b4e88e9d4519a3e4abe1cfd"
 dependencies = [
 "serde",
 ]
@@ -13702,7 +13710,7 @@ dependencies = [
 "settings",
 "simplelog",
 "story",
- "strum",
+ "strum 0.27.1",
 "theme",
 "title_bar",
 "ui",
@@ -13784,7 +13792,16 @@ version = "0.26.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06"
 dependencies = [
- "strum_macros",
+ "strum_macros 0.26.4",
+]
+
+[[package]]
+name = "strum"
+version = "0.27.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f64def088c51c9510a8579e3c5d67c65349dcf755e5479ad3d010aa6454e2c32"
+dependencies = [
+ "strum_macros 0.27.1",
 ]

 [[package]]
@@ -13800,6 +13817,19 @@ dependencies = [
 "syn 2.0.100",
 ]

+[[package]]
+name = "strum_macros"
+version = "0.27.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c77a8c5abcaf0f9ce05d62342b7d298c346515365c36b673df4ebe3ced01fde8"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn 2.0.100",
+]
+
 [[package]]
 name = "subtle"
 version = "2.6.1"
@@ -14415,7 +14445,7 @@ dependencies = [
 "serde_json_lenient",
 "serde_repr",
 "settings",
- "strum",
+ "strum 0.27.1",
 "thiserror 2.0.12",
 "util",
 "uuid",
@@ -14449,7 +14479,7 @@ dependencies = [
 "serde_json",
 "serde_json_lenient",
 "simplelog",
- "strum",
+ "strum 0.27.1",
 "theme",
 "vscode_theme",
 "workspace-hack",
@@ -15450,7 +15480,7 @@ dependencies = [
 "settings",
 "smallvec",
 "story",
- "strum",
+ "strum 0.27.1",
 "theme",
 "ui_macros",
 "util",
@@ -16583,6 +16613,36 @@ dependencies = [
 "wasm-bindgen",
 ]

+[[package]]
+name = "web_search"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "collections",
+ "gpui",
+ "serde",
+ "workspace-hack",
+ "zed_llm_client",
+]
+
+[[package]]
+name = "web_search_providers"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "client",
+ "feature_flags",
+ "futures 0.3.31",
+ "gpui",
+ "http_client",
+ "language_model",
+ "serde",
+ "serde_json",
+ "web_search",
+ "workspace-hack",
+ "zed_llm_client",
+]
+
 [[package]]
 name = "webpki-root-certs"
 version = "0.26.8"
@@ -17621,7 +17681,7 @@ dependencies = [
 "settings",
 "smallvec",
 "sqlez",
- "strum",
+ "strum 0.27.1",
 "task",
 "telemetry",
 "tempfile",
@@ -17766,7 +17826,7 @@ dependencies = [
 "sqlx-macros-core",
 "sqlx-postgres",
 "sqlx-sqlite",
- "strum",
+ "strum 0.26.3",
 "subtle",
 "syn 1.0.109",
 "syn 2.0.100",
@@ -18138,12 +18198,13 @@ dependencies = [

 [[package]]
 name = "zed"
-version = "0.183.0"
+version = "0.184.0"
 dependencies = [
 "activity_indicator",
 "agent",
 "anyhow",
 "ashpd",
+ "askpass",
 "assets",
 "assistant",
 "assistant_context_editor",
@@ -18261,6 +18322,8 @@ dependencies = [
 "uuid",
 "vim",
 "vim_mode_setting",
+ "web_search",
+ "web_search_providers",
 "welcome",
 "windows 0.61.1",
 "winresource",
@@ -18325,12 +18388,13 @@ dependencies = [

 [[package]]
 name = "zed_llm_client"
-version = "0.4.1"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bf21350eced858d129840589158a8f6895c4fa4327ae56dd8c7d6a98495bed4"
+checksum = "9ee4d410dbc030c3e6e3af78fc76296f6bebe20dcb6d7d3fa24bca306fc8c1ce"
 dependencies = [
 "serde",
 "serde_json",
+ "strum 0.27.1",
 "uuid",
 ]

--- a/Cargo.toml
+++ b/Cargo.toml
@@ -165,6 +165,8 @@ members = [
    "crates/util_macros",
    "crates/vim",
    "crates/vim_mode_setting",
+    "crates/web_search",
+    "crates/web_search_providers",
    "crates/welcome",
    "crates/workspace",
    "crates/worktree",
@@ -370,6 +372,8 @@ util = { path = "crates/util" }
 util_macros = { path = "crates/util_macros" }
 vim = { path = "crates/vim" }
 vim_mode_setting = { path = "crates/vim_mode_setting" }
+web_search = { path = "crates/web_search" }
+web_search_providers = { path = "crates/web_search_providers" }
 welcome = { path = "crates/welcome" }
 workspace = { path = "crates/workspace" }
 worktree = { path = "crates/worktree" }
@@ -536,7 +540,7 @@ smol = "2.0"
 sqlformat = "0.2"
 streaming-iterator = "0.1"
 strsim = "0.11"
-strum = { version = "0.26.0", features = ["derive"] }
+strum = { version = "0.27.0", features = ["derive"] }
 subtle = "2.5.0"
 syn = { version = "1.0.72", features = ["full", "extra-traits"] }
 sys-locale = "0.3.1"
@@ -601,7 +605,7 @@ wasmtime-wasi = "29"
 which = "6.0.0"
 wit-component = "0.221"
 workspace-hack = "0.1.0"
-zed_llm_client = "0.4"
+zed_llm_client = "0.5.1"
 zstd = "0.11"
 metal = "0.29"

--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -134,7 +134,9 @@
      "shift-f10": "editor::OpenContextMenu",
      "ctrl-shift-e": "editor::ToggleEditPrediction",
      "f9": "editor::ToggleBreakpoint",
-      "shift-f9": "editor::EditLogBreakpoint"
+      "shift-f9": "editor::EditLogBreakpoint",
+      "ctrl-shift-backspace": "editor::GoToPreviousChange",
+      "ctrl-shift-alt-backspace": "editor::GoToNextChange"
    }
  },
  {
@@ -630,6 +632,7 @@
      "ctrl-alt-n": "agent::NewTextThread",
      "ctrl-shift-h": "agent::OpenHistory",
      "ctrl-alt-c": "agent::OpenConfiguration",
+      "ctrl-alt-p": "assistant::OpenPromptLibrary",
      "ctrl-i": "agent::ToggleProfileSelector",
      "ctrl-alt-/": "assistant::ToggleModelSelector",
      "ctrl-shift-a": "agent::ToggleContextPicker",
@@ -718,7 +721,7 @@
      "alt-shift-copy": "workspace::CopyRelativePath",
      "alt-ctrl-shift-c": "workspace::CopyRelativePath",
      "alt-ctrl-r": "outline_panel::RevealInFileManager",
-      "space": "outline_panel::Open",
+      "space": "outline_panel::OpenSelectedEntry",
      "shift-down": "menu::SelectNext",
      "shift-up": "menu::SelectPrevious",
      "alt-enter": "editor::OpenExcerpts",
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -286,6 +286,7 @@
      "cmd-alt-n": "agent::NewTextThread",
      "cmd-shift-h": "agent::OpenHistory",
      "cmd-alt-c": "agent::OpenConfiguration",
+      "cmd-alt-p": "assistant::OpenPromptLibrary",
      "cmd-i": "agent::ToggleProfileSelector",
      "cmd-alt-/": "assistant::ToggleModelSelector",
      "cmd-shift-a": "agent::ToggleContextPicker",
@@ -541,7 +542,9 @@
      "cmd-\\": "pane::SplitRight",
      "cmd-k v": "markdown::OpenPreviewToTheSide",
      "cmd-shift-v": "markdown::OpenPreview",
-      "ctrl-cmd-c": "editor::DisplayCursorNames"
+      "ctrl-cmd-c": "editor::DisplayCursorNames",
+      "cmd-shift-backspace": "editor::GoToPreviousChange",
+      "cmd-shift-alt-backspace": "editor::GoToNextChange"
    }
  },
  {
@@ -786,7 +789,7 @@
      "cmd-alt-c": "workspace::CopyPath",
      "alt-cmd-shift-c": "workspace::CopyRelativePath",
      "alt-cmd-r": "outline_panel::RevealInFileManager",
-      "space": "outline_panel::Open",
+      "space": "outline_panel::OpenSelectedEntry",
      "shift-down": "menu::SelectNext",
      "shift-up": "menu::SelectPrevious",
      "alt-enter": "editor::OpenExcerpts",
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -652,7 +652,8 @@
          "path_search": true,
          "read_file": true,
          "regex_search": true,
-          "thinking": true
+          "thinking": true,
+          "web_search": true
        }
      },
      "write": {
@@ -678,7 +679,8 @@
          "regex_search": true,
          "rename": true,
          "symbol_info": true,
-          "thinking": true
+          "thinking": true,
+          "web_search": true
        }
      }
    },
--- a/crates/agent/src/active_thread.rs
+++ b/crates/agent/src/active_thread.rs
@@ -1,27 +1,30 @@
-use crate::context::{AssistantContext, ContextId};
+use crate::context::{AssistantContext, ContextId, format_context_as_string};
 use crate::context_picker::MentionLink;
 use crate::thread::{
    LastRestoreCheckpoint, MessageId, MessageSegment, RequestKind, Thread, ThreadError,
    ThreadEvent, ThreadFeedback,
 };
 use crate::thread_store::{RulesLoadingError, ThreadStore};
-use crate::tool_use::{PendingToolUseStatus, ToolUse, ToolUseStatus};
+use crate::tool_use::{PendingToolUseStatus, ToolUse};
 use crate::ui::{AddedContext, AgentNotification, AgentNotificationEvent, ContextPill};
 use crate::{AssistantPanel, OpenActiveThreadAsMarkdown};
 use anyhow::Context as _;
 use assistant_settings::{AssistantSettings, NotifyWhenAgentWaiting};
+use assistant_tool::ToolUseStatus;
 use collections::{HashMap, HashSet};
 use editor::scroll::Autoscroll;
-use editor::{Editor, EditorElement, EditorStyle, MultiBuffer};
+use editor::{Editor, EditorElement, EditorEvent, EditorStyle, MultiBuffer};
 use gpui::{
    AbsoluteLength, Animation, AnimationExt, AnyElement, App, ClickEvent, ClipboardItem,
-    DefiniteLength, EdgesRefinement, Empty, Entity, Focusable, Hsla, ListAlignment, ListState,
-    MouseButton, PlatformDisplay, ScrollHandle, Stateful, StyleRefinement, Subscription, Task,
-    TextStyle, TextStyleRefinement, Transformation, UnderlineStyle, WeakEntity, WindowHandle,
+    DefiniteLength, EdgesRefinement, Empty, Entity, EventEmitter, Focusable, Hsla, ListAlignment,
+    ListState, MouseButton, PlatformDisplay, ScrollHandle, Stateful, StyleRefinement, Subscription,
+    Task, TextStyle, TextStyleRefinement, Transformation, UnderlineStyle, WeakEntity, WindowHandle,
    linear_color_stop, linear_gradient, list, percentage, pulsating_between,
 };
 use language::{Buffer, LanguageRegistry};
-use language_model::{LanguageModelRegistry, LanguageModelToolUseId, Role, StopReason};
+use language_model::{
+    LanguageModelRegistry, LanguageModelRequestMessage, LanguageModelToolUseId, Role, StopReason,
+};
 use markdown::parser::{CodeBlockKind, CodeBlockMetadata};
 use markdown::{HeadingLevelStyles, Markdown, MarkdownElement, MarkdownStyle, ParsedMarkdown};
 use project::ProjectItem as _;
@@ -681,6 +684,9 @@ fn open_markdown_link(

 struct EditMessageState {
    editor: Entity<Editor>,
+    last_estimated_token_count: Option<usize>,
+    _subscription: Subscription,
+    _update_token_count_task: Option<Task<anyhow::Result<()>>>,
 }

 impl ActiveThread {
@@ -780,6 +786,13 @@ impl ActiveThread {
        self.last_error.take();
    }

+    /// Returns the editing message id and the estimated token count in the content
+    pub fn editing_message_id(&self) -> Option<(MessageId, usize)> {
+        self.editing_message
+            .as_ref()
+            .map(|(id, state)| (*id, state.last_estimated_token_count.unwrap_or(0)))
+    }
+
    fn push_message(
        &mut self,
        id: &MessageId,
@@ -943,8 +956,8 @@ impl ActiveThread {
                        &tool_use.input,
                        self.thread
                            .read(cx)
-                            .tool_result(&tool_use.id)
-                            .map(|result| result.content.clone().into())
+                            .output_for_tool(&tool_use.id)
+                            .map(|output| output.clone().into())
                            .unwrap_or("".into()),
                        cx,
                    );
@@ -1125,15 +1138,91 @@ impl ActiveThread {
            editor.move_to_end(&editor::actions::MoveToEnd, window, cx);
            editor
        });
+        let subscription = cx.subscribe(&editor, |this, _, event, cx| match event {
+            EditorEvent::BufferEdited => {
+                this.update_editing_message_token_count(true, cx);
+            }
+            _ => {}
+        });
        self.editing_message = Some((
            message_id,
            EditMessageState {
                editor: editor.clone(),
+                last_estimated_token_count: None,
+                _subscription: subscription,
+                _update_token_count_task: None,
            },
        ));
+        self.update_editing_message_token_count(false, cx);
        cx.notify();
    }

+    fn update_editing_message_token_count(&mut self, debounce: bool, cx: &mut Context<Self>) {
+        let Some((message_id, state)) = self.editing_message.as_mut() else {
+            return;
+        };
+
+        cx.emit(ActiveThreadEvent::EditingMessageTokenCountChanged);
+        state._update_token_count_task.take();
+
+        let Some(default_model) = LanguageModelRegistry::read_global(cx).default_model() else {
+            state.last_estimated_token_count.take();
+            return;
+        };
+
+        let editor = state.editor.clone();
+        let thread = self.thread.clone();
+        let message_id = *message_id;
+
+        state._update_token_count_task = Some(cx.spawn(async move |this, cx| {
+            if debounce {
+                cx.background_executor()
+                    .timer(Duration::from_millis(200))
+                    .await;
+            }
+
+            let token_count = if let Some(task) = cx.update(|cx| {
+                let context = thread.read(cx).context_for_message(message_id);
+                let new_context = thread.read(cx).filter_new_context(context);
+                let context_text =
+                    format_context_as_string(new_context, cx).unwrap_or(String::new());
+                let message_text = editor.read(cx).text(cx);
+
+                let content = context_text + &message_text;
+
+                if content.is_empty() {
+                    return None;
+                }
+
+                let request = language_model::LanguageModelRequest {
+                    messages: vec![LanguageModelRequestMessage {
+                        role: language_model::Role::User,
+                        content: vec![content.into()],
+                        cache: false,
+                    }],
+                    tools: vec![],
+                    stop: vec![],
+                    temperature: None,
+                };
+
+                Some(default_model.model.count_tokens(request, cx))
+            })? {
+                task.await?
+            } else {
+                0
+            };
+
+            this.update(cx, |this, cx| {
+                let Some((_message_id, state)) = this.editing_message.as_mut() else {
+                    return;
+                };
+
+                state.last_estimated_token_count = Some(token_count);
+                cx.emit(ActiveThreadEvent::EditingMessageTokenCountChanged);
+            })
+        }));
+    }
+
    fn cancel_editing_message(&mut self, _: &menu::Cancel, _: &mut Window, cx: &mut Context<Self>) {
        self.editing_message.take();
        cx.notify();
@@ -1675,6 +1764,9 @@ impl ActiveThread {
                                                        "confirm-edit-message",
                                                        "Regenerate",
                                                    )
+                                                    .disabled(
+                                                        edit_message_editor.read(cx).is_empty(cx),
+                                                    )
                                                    .label_size(LabelSize::Small)
                                                    .key_binding(
                                                        KeyBinding::for_action_in(
@@ -1737,8 +1829,16 @@ impl ActiveThread {
            ),
        };

+        let after_editing_message = self
+            .editing_message
+            .as_ref()
+            .map_or(false, |(editing_message_id, _)| {
+                message_id > *editing_message_id
+            });
+
        v_flex()
            .w_full()
+            .when(after_editing_message, |parent| parent.opacity(0.2))
            .when_some(checkpoint, |parent, checkpoint| {
                let mut is_pending = false;
                let mut error = None;
@@ -2279,12 +2379,15 @@ impl ActiveThread {
        window: &mut Window,
        cx: &mut Context<Self>,
    ) -> impl IntoElement + use<> {
+        if let Some(card) = self.thread.read(cx).card_for_tool(&tool_use.id) {
+            return card.render(&tool_use.status, window, cx);
+        }
+
        let is_open = self
            .expanded_tool_uses
            .get(&tool_use.id)
            .copied()
            .unwrap_or_default();
-
        let is_status_finished = matches!(&tool_use.status, ToolUseStatus::Finished(_));

        let fs = self
@@ -2343,6 +2446,9 @@ impl ActiveThread {
                                    rendered.input.clone(),
                                    tool_use_markdown_style(window, cx),
                                )
+                                .code_block_renderer(markdown::CodeBlockRenderer::Default {
+                                    copy_button: false,
+                                })
                                .on_url_click({
                                    let workspace = self.workspace.clone();
                                    move |text, window, cx| {
@@ -2369,12 +2475,16 @@ impl ActiveThread {
                                    rendered.output.clone(),
                                    tool_use_markdown_style(window, cx),
                                )
+                                .code_block_renderer(markdown::CodeBlockRenderer::Default {
+                                    copy_button: false,
+                                })
                                .on_url_click({
                                    let workspace = self.workspace.clone();
                                    move |text, window, cx| {
                                        open_markdown_link(text, workspace.clone(), window, cx);
                                    }
                                })
+                                .into_any_element()
                            }),
                        )),
                ),
@@ -2431,6 +2541,7 @@ impl ActiveThread {
                                            open_markdown_link(text, workspace.clone(), window, cx);
                                        }
                                    })
+                                    .into_any_element()
                                })),
                        ),
                ),
@@ -2544,7 +2655,7 @@ impl ActiveThread {
                )
            } else {
                v_flex()
-                    .my_3()
+                    .my_2()
                    .rounded_lg()
                    .border_1()
                    .border_color(self.tool_card_border_color(cx))
@@ -2761,7 +2872,7 @@ impl ActiveThread {
                        )
                    })
            }
-        })
+        }).into_any_element()
    }

    fn render_rules_item(&self, cx: &Context<Self>) -> AnyElement {
@@ -2953,6 +3064,12 @@ impl ActiveThread {
    }
 }

+pub enum ActiveThreadEvent {
+    EditingMessageTokenCountChanged,
+}
+
+impl EventEmitter<ActiveThreadEvent> for ActiveThread {}
+
 impl Render for ActiveThread {
    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
        v_flex()
--- a/crates/agent/src/agent_diff.rs
+++ b/crates/agent/src/agent_diff.rs
@@ -1,7 +1,7 @@
 use crate::{Keep, KeepAll, Reject, RejectAll, Thread, ThreadEvent};
 use anyhow::Result;
 use buffer_diff::DiffHunkStatus;
-use collections::HashSet;
+use collections::{HashMap, HashSet};
 use editor::{
    Direction, Editor, EditorEvent, MultiBuffer, ToPoint,
    actions::{GoToHunk, GoToPreviousHunk},
@@ -355,16 +355,24 @@ impl AgentDiff {
            self.update_selection(&diff_hunks_in_ranges, window, cx);
        }

+        let mut ranges_by_buffer = HashMap::default();
        for hunk in &diff_hunks_in_ranges {
            let buffer = self.multibuffer.read(cx).buffer(hunk.buffer_id);
            if let Some(buffer) = buffer {
-                self.thread
-                    .update(cx, |thread, cx| {
-                        thread.reject_edits_in_range(buffer, hunk.buffer_range.clone(), cx)
-                    })
-                    .detach_and_log_err(cx);
+                ranges_by_buffer
+                    .entry(buffer.clone())
+                    .or_insert_with(Vec::new)
+                    .push(hunk.buffer_range.clone());
            }
        }
+
+        for (buffer, ranges) in ranges_by_buffer {
+            self.thread
+                .update(cx, |thread, cx| {
+                    thread.reject_edits_in_ranges(buffer, ranges, cx)
+                })
+                .detach_and_log_err(cx);
+        }
    }

    fn update_selection(
--- a/crates/agent/src/assistant_configuration.rs
+++ b/crates/agent/src/assistant_configuration.rs
@@ -9,11 +9,14 @@ use assistant_tool::{ToolSource, ToolWorkingSet};
 use collections::HashMap;
 use context_server::manager::ContextServerManager;
 use fs::Fs;
-use gpui::{Action, AnyView, App, Entity, EventEmitter, FocusHandle, Focusable, Subscription};
+use gpui::{
+    Action, AnyView, App, Entity, EventEmitter, FocusHandle, Focusable, ScrollHandle, Subscription,
+};
 use language_model::{LanguageModelProvider, LanguageModelProviderId, LanguageModelRegistry};
 use settings::{Settings, update_settings_file};
 use ui::{
-    Disclosure, Divider, DividerColor, ElevationIndex, Indicator, Switch, Tooltip, prelude::*,
+    Disclosure, Divider, DividerColor, ElevationIndex, Indicator, Scrollbar, ScrollbarState,
+    Switch, Tooltip, prelude::*,
 };
 use util::ResultExt as _;
 use zed_actions::ExtensionCategoryFilter;
@@ -31,6 +34,8 @@ pub struct AssistantConfiguration {
    expanded_context_server_tools: HashMap<Arc<str>, bool>,
    tools: Entity<ToolWorkingSet>,
    _registry_subscription: Subscription,
+    scroll_handle: ScrollHandle,
+    scrollbar_state: ScrollbarState,
 }

 impl AssistantConfiguration {
@@ -60,6 +65,9 @@ impl AssistantConfiguration {
            },
        );

+        let scroll_handle = ScrollHandle::new();
+        let scrollbar_state = ScrollbarState::new(scroll_handle.clone());
+
        let mut this = Self {
            fs,
            focus_handle,
@@ -68,6 +76,8 @@ impl AssistantConfiguration {
            expanded_context_server_tools: HashMap::default(),
            tools,
            _registry_subscription: registry_subscription,
+            scroll_handle,
+            scrollbar_state,
        };
        this.build_provider_configuration_views(window, cx);
        this
@@ -109,7 +119,7 @@ pub enum AssistantConfigurationEvent {
 impl EventEmitter<AssistantConfigurationEvent> for AssistantConfiguration {}

 impl AssistantConfiguration {
-    fn render_provider_configuration(
+    fn render_provider_configuration_block(
        &mut self,
        provider: &Arc<dyn LanguageModelProvider>,
        cx: &mut Context<Self>,
@@ -164,7 +174,7 @@ impl AssistantConfiguration {
                    .p(DynamicSpacing::Base08.rems(cx))
                    .bg(cx.theme().colors().editor_background)
                    .border_1()
-                    .border_color(cx.theme().colors().border_variant)
+                    .border_color(cx.theme().colors().border)
                    .rounded_sm()
                    .map(|parent| match configuration_view {
                        Some(configuration_view) => parent.child(configuration_view),
@@ -175,6 +185,33 @@ impl AssistantConfiguration {
            )
    }

+    fn render_provider_configuration_section(
+        &mut self,
+        cx: &mut Context<Self>,
+    ) -> impl IntoElement {
+        let providers = LanguageModelRegistry::read_global(cx).providers();
+
+        v_flex()
+            .p(DynamicSpacing::Base16.rems(cx))
+            .pr(DynamicSpacing::Base20.rems(cx))
+            .gap_4()
+            .flex_1()
+            .child(
+                v_flex()
+                    .gap_0p5()
+                    .child(Headline::new("LLM Providers").size(HeadlineSize::Small))
+                    .child(
+                        Label::new("Add at least one provider to use AI-powered features.")
+                            .color(Color::Muted),
+                    ),
+            )
+            .children(
+                providers
+                    .into_iter()
+                    .map(|provider| self.render_provider_configuration_block(&provider, cx)),
+            )
+    }
+
    fn render_command_permission(&mut self, cx: &mut Context<Self>) -> impl IntoElement {
        let always_allow_tool_actions = AssistantSettings::get_global(cx).always_allow_tool_actions;

@@ -182,6 +219,7 @@ impl AssistantConfiguration {

        v_flex()
            .p(DynamicSpacing::Base16.rems(cx))
+            .pr(DynamicSpacing::Base20.rems(cx))
            .gap_2()
            .flex_1()
            .child(Headline::new("General Settings").size(HeadlineSize::Small))
@@ -233,6 +271,7 @@ impl AssistantConfiguration {

        v_flex()
            .p(DynamicSpacing::Base16.rems(cx))
+            .pr(DynamicSpacing::Base20.rems(cx))
            .gap_2()
            .flex_1()
            .child(
@@ -426,39 +465,51 @@ impl AssistantConfiguration {

 impl Render for AssistantConfiguration {
    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let providers = LanguageModelRegistry::read_global(cx).providers();
-
        v_flex()
            .id("assistant-configuration")
            .key_context("AgentConfiguration")
            .track_focus(&self.focus_handle(cx))
-            .bg(cx.theme().colors().panel_background)
+            .relative()
            .size_full()
-            .overflow_y_scroll()
-            .child(self.render_command_permission(cx))
-            .child(Divider::horizontal().color(DividerColor::Border))
-            .child(self.render_context_servers_section(cx))
-            .child(Divider::horizontal().color(DividerColor::Border))
+            .pb_8()
+            .bg(cx.theme().colors().panel_background)
            .child(
                v_flex()
-                    .p(DynamicSpacing::Base16.rems(cx))
-                    .mt_1()
-                    .gap_6()
-                    .flex_1()
-                    .child(
-                        v_flex()
-                            .gap_0p5()
-                            .child(Headline::new("LLM Providers").size(HeadlineSize::Small))
-                            .child(
-                                Label::new("Add at least one provider to use AI-powered features.")
-                                    .color(Color::Muted),
-                            ),
-                    )
-                    .children(
-                        providers
-                            .into_iter()
-                            .map(|provider| self.render_provider_configuration(&provider, cx)),
-                    ),
+                    .id("assistant-configuration-content")
+                    .track_scroll(&self.scroll_handle)
+                    .size_full()
+                    .overflow_y_scroll()
+                    .child(self.render_command_permission(cx))
+                    .child(Divider::horizontal().color(DividerColor::Border))
+                    .child(self.render_context_servers_section(cx))
+                    .child(Divider::horizontal().color(DividerColor::Border))
+                    .child(self.render_provider_configuration_section(cx)),
+            )
+            .child(
+                div()
+                    .id("assistant-configuration-scrollbar")
+                    .occlude()
+                    .absolute()
+                    .right(px(3.))
+                    .top_0()
+                    .bottom_0()
+                    .pb_6()
+                    .w(px(12.))
+                    .cursor_default()
+                    .on_mouse_move(cx.listener(|_, _, _window, cx| {
+                        cx.notify();
+                        cx.stop_propagation()
+                    }))
+                    .on_hover(|_, _window, cx| {
+                        cx.stop_propagation();
+                    })
+                    .on_any_mouse_down(|_, _window, cx| {
+                        cx.stop_propagation();
+                    })
+                    .on_scroll_wheel(cx.listener(|_, _, _window, cx| {
+                        cx.notify();
+                    }))
+                    .children(Scrollbar::vertical(self.scrollbar_state.clone())),
            )
    }
 }
--- a/crates/agent/src/assistant_panel.rs
+++ b/crates/agent/src/assistant_panel.rs
@@ -5,7 +5,7 @@ use std::time::Duration;
 use anyhow::{Result, anyhow};
 use assistant_context_editor::{
    AssistantPanelDelegate, ConfigurationError, ContextEditor, SlashCommandCompletionProvider,
-    make_lsp_adapter_delegate, render_remaining_tokens,
+    humanize_token_count, make_lsp_adapter_delegate, render_remaining_tokens,
 };
 use assistant_settings::{AssistantDockPosition, AssistantSettings};
 use assistant_slash_command::SlashCommandWorkingSet;
@@ -25,6 +25,7 @@ use language_model_selector::ToggleModelSelector;
 use project::Project;
 use prompt_library::{PromptLibrary, open_prompt_library};
 use prompt_store::PromptBuilder;
+use proto::Plan;
 use settings::{Settings, update_settings_file};
 use time::UtcOffset;
 use ui::{
@@ -36,10 +37,10 @@ use workspace::dock::{DockPosition, Panel, PanelEvent};
 use zed_actions::agent::OpenConfiguration;
 use zed_actions::assistant::{OpenPromptLibrary, ToggleFocus};

-use crate::active_thread::ActiveThread;
+use crate::active_thread::{ActiveThread, ActiveThreadEvent};
 use crate::assistant_configuration::{AssistantConfiguration, AssistantConfigurationEvent};
 use crate::history_store::{HistoryEntry, HistoryStore};
-use crate::message_editor::MessageEditor;
+use crate::message_editor::{MessageEditor, MessageEditorEvent};
 use crate::thread::{Thread, ThreadError, ThreadId, TokenUsageRatio};
 use crate::thread_history::{PastContext, PastThread, ThreadHistory};
 use crate::thread_store::ThreadStore;
@@ -180,8 +181,8 @@ pub struct AssistantPanel {
    language_registry: Arc<LanguageRegistry>,
    thread_store: Entity<ThreadStore>,
    thread: Entity<ActiveThread>,
-    _thread_subscription: Subscription,
    message_editor: Entity<MessageEditor>,
+    _active_thread_subscriptions: Vec<Subscription>,
    context_store: Entity<assistant_context_editor::ContextStore>,
    context_editor: Option<Entity<ContextEditor>>,
    configuration: Option<Entity<AssistantConfiguration>>,
@@ -263,6 +264,13 @@ impl AssistantPanel {
            )
        });

+        let message_editor_subscription =
+            cx.subscribe(&message_editor, |_, _, event, cx| match event {
+                MessageEditorEvent::Changed | MessageEditorEvent::EstimatedTokenCount => {
+                    cx.notify();
+                }
+            });
+
        let history_store =
            cx.new(|cx| HistoryStore::new(thread_store.clone(), context_store.clone(), cx));

@@ -287,6 +295,12 @@ impl AssistantPanel {
            )
        });

+        let active_thread_subscription = cx.subscribe(&thread, |_, _, event, cx| match &event {
+            ActiveThreadEvent::EditingMessageTokenCountChanged => {
+                cx.notify();
+            }
+        });
+
        Self {
            active_view,
            workspace,
@@ -295,8 +309,12 @@ impl AssistantPanel {
            language_registry,
            thread_store: thread_store.clone(),
            thread,
-            _thread_subscription: thread_subscription,
            message_editor,
+            _active_thread_subscriptions: vec![
+                thread_subscription,
+                active_thread_subscription,
+                message_editor_subscription,
+            ],
            context_store,
            context_editor: None,
            configuration: None,
@@ -381,6 +399,13 @@ impl AssistantPanel {
            .detach_and_log_err(cx);
        }

+        let thread_subscription = cx.subscribe(&thread, |_, _, event, cx| {
+            if let ThreadEvent::MessageAdded(_) = &event {
+                // needed to leave empty state
+                cx.notify();
+            }
+        });
+
        self.thread = cx.new(|cx| {
            ActiveThread::new(
                thread.clone(),
@@ -393,12 +418,12 @@ impl AssistantPanel {
            )
        });

-        self._thread_subscription = cx.subscribe(&thread, |_, _, event, cx| {
-            if let ThreadEvent::MessageAdded(_) = &event {
-                // needed to leave empty state
-                cx.notify();
-            }
-        });
+        let active_thread_subscription =
+            cx.subscribe(&self.thread, |_, _, event, cx| match &event {
+                ActiveThreadEvent::EditingMessageTokenCountChanged => {
+                    cx.notify();
+                }
+            });

        self.message_editor = cx.new(|cx| {
            MessageEditor::new(
@@ -412,6 +437,19 @@ impl AssistantPanel {
            )
        });
        self.message_editor.focus_handle(cx).focus(window);
+
+        let message_editor_subscription =
+            cx.subscribe(&self.message_editor, |_, _, event, cx| match event {
+                MessageEditorEvent::Changed | MessageEditorEvent::EstimatedTokenCount => {
+                    cx.notify();
+                }
+            });
+
+        self._active_thread_subscriptions = vec![
+            thread_subscription,
+            active_thread_subscription,
+            message_editor_subscription,
+        ];
    }

    fn new_prompt_editor(&mut self, window: &mut Window, cx: &mut Context<Self>) {
@@ -537,6 +575,13 @@ impl AssistantPanel {
                        Some(this.thread_store.downgrade()),
                    )
                });
+                let thread_subscription = cx.subscribe(&thread, |_, _, event, cx| {
+                    if let ThreadEvent::MessageAdded(_) = &event {
+                        // needed to leave empty state
+                        cx.notify();
+                    }
+                });
+
                this.thread = cx.new(|cx| {
                    ActiveThread::new(
                        thread.clone(),
@@ -548,6 +593,14 @@ impl AssistantPanel {
                        cx,
                    )
                });
+
+                let active_thread_subscription =
+                    cx.subscribe(&this.thread, |_, _, event, cx| match &event {
+                        ActiveThreadEvent::EditingMessageTokenCountChanged => {
+                            cx.notify();
+                        }
+                    });
+
                this.message_editor = cx.new(|cx| {
                    MessageEditor::new(
                        this.fs.clone(),
@@ -560,6 +613,19 @@ impl AssistantPanel {
                    )
                });
                this.message_editor.focus_handle(cx).focus(window);
+
+                let message_editor_subscription =
+                    cx.subscribe(&this.message_editor, |_, _, event, cx| match event {
+                        MessageEditorEvent::Changed | MessageEditorEvent::EstimatedTokenCount => {
+                            cx.notify();
+                        }
+                    });
+
+                this._active_thread_subscriptions = vec![
+                    thread_subscription,
+                    active_thread_subscription,
+                    message_editor_subscription,
+                ];
            })
        })
    }
@@ -852,7 +918,7 @@ impl Panel for AssistantPanel {
 }

 impl AssistantPanel {
-    fn render_title_view(&self, _window: &mut Window, cx: &mut Context<Self>) -> AnyElement {
+    fn render_title_view(&self, _window: &mut Window, cx: &Context<Self>) -> AnyElement {
        const LOADING_SUMMARY_PLACEHOLDER: &str = "Loading Summary…";

        let content = match &self.active_view {
@@ -912,13 +978,8 @@ impl AssistantPanel {
    fn render_toolbar(&self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
        let active_thread = self.thread.read(cx);
        let thread = active_thread.thread().read(cx);
-        let token_usage = thread.total_token_usage(cx);
        let thread_id = thread.id().clone();
-
-        let is_generating = thread.is_generating();
        let is_empty = active_thread.is_empty();
-        let focus_handle = self.focus_handle(cx);
-
        let is_history = matches!(self.active_view, ActiveView::History);

        let show_token_count = match &self.active_view {
@@ -927,6 +988,8 @@ impl AssistantPanel {
            _ => false,
        };

+        let focus_handle = self.focus_handle(cx);
+
        let go_back_button = match &self.active_view {
            ActiveView::History | ActiveView::Configuration => Some(
                div().pl_1().child(
@@ -973,69 +1036,9 @@ impl AssistantPanel {
                h_flex()
                    .h_full()
                    .gap_2()
-                    .when(show_token_count, |parent| match self.active_view {
-                        ActiveView::Thread { .. } => {
-                            if token_usage.total == 0 {
-                                return parent;
-                            }
-
-                            let token_color = match token_usage.ratio {
-                                TokenUsageRatio::Normal => Color::Muted,
-                                TokenUsageRatio::Warning => Color::Warning,
-                                TokenUsageRatio::Exceeded => Color::Error,
-                            };
-
-                            parent.child(
-                                h_flex()
-                                    .flex_shrink_0()
-                                    .gap_0p5()
-                                    .child(
-                                        Label::new(assistant_context_editor::humanize_token_count(
-                                            token_usage.total,
-                                        ))
-                                        .size(LabelSize::Small)
-                                        .color(token_color)
-                                        .map(|label| {
-                                            if is_generating {
-                                                label
-                                                    .with_animation(
-                                                        "used-tokens-label",
-                                                        Animation::new(Duration::from_secs(2))
-                                                            .repeat()
-                                                            .with_easing(pulsating_between(
-                                                                0.6, 1.,
-                                                            )),
-                                                        |label, delta| label.alpha(delta),
-                                                    )
-                                                    .into_any()
-                                            } else {
-                                                label.into_any_element()
-                                            }
-                                        }),
-                                    )
-                                    .child(
-                                        Label::new("/").size(LabelSize::Small).color(Color::Muted),
-                                    )
-                                    .child(
-                                        Label::new(assistant_context_editor::humanize_token_count(
-                                            token_usage.max,
-                                        ))
-                                        .size(LabelSize::Small)
-                                        .color(Color::Muted),
-                                    ),
-                            )
-                        }
-                        ActiveView::PromptEditor => {
-                            let Some(editor) = self.context_editor.as_ref() else {
-                                return parent;
-                            };
-                            let Some(element) = render_remaining_tokens(editor, cx) else {
-                                return parent;
-                            };
-                            parent.child(element)
-                        }
-                        _ => parent,
-                    })
+                    .when(show_token_count, |parent|
+                        parent.children(self.render_token_count(&thread, cx))
+                    )
                    .child(
                        h_flex()
                            .h_full()
@@ -1112,16 +1115,16 @@ impl AssistantPanel {
                                                    "New Text Thread",
                                                    NewTextThread.boxed_clone(),
                                                )
-                                                .action("Settings", OpenConfiguration.boxed_clone())
+                                                .action("Prompt Library", Box::new(OpenPromptLibrary))
+                                                .action("Settings", Box::new(OpenConfiguration))
                                                .separator()
                                                .action(
                                                    "Install MCPs",
-                                                    zed_actions::Extensions {
+                                                    Box::new(zed_actions::Extensions {
                                                        category_filter: Some(
                                                            zed_actions::ExtensionCategoryFilter::ContextServers,
                                                        ),
-                                                    }
-                                                    .boxed_clone(),
+                                                        }),
                                                )
                                            },
                                        ))
@@ -1131,6 +1134,111 @@ impl AssistantPanel {
            )
    }

+    fn render_token_count(&self, thread: &Thread, cx: &App) -> Option<AnyElement> {
+        let is_generating = thread.is_generating();
+        let message_editor = self.message_editor.read(cx);
+
+        let conversation_token_usage = thread.total_token_usage(cx);
+        let (total_token_usage, is_estimating) = if let Some((editing_message_id, unsent_tokens)) =
+            self.thread.read(cx).editing_message_id()
+        {
+            let combined = thread
+                .token_usage_up_to_message(editing_message_id, cx)
+                .add(unsent_tokens);
+
+            (combined, unsent_tokens > 0)
+        } else {
+            let unsent_tokens = message_editor.last_estimated_token_count().unwrap_or(0);
+            let combined = conversation_token_usage.add(unsent_tokens);
+
+            (combined, unsent_tokens > 0)
+        };
+
+        let is_waiting_to_update_token_count = message_editor.is_waiting_to_update_token_count();
+
+        match self.active_view {
+            ActiveView::Thread { .. } => {
+                if total_token_usage.total == 0 {
+                    return None;
+                }
+
+                let token_color = match total_token_usage.ratio() {
+                    TokenUsageRatio::Normal if is_estimating => Color::Default,
+                    TokenUsageRatio::Normal => Color::Muted,
+                    TokenUsageRatio::Warning => Color::Warning,
+                    TokenUsageRatio::Exceeded => Color::Error,
+                };
+
+                let token_count = h_flex()
+                    .id("token-count")
+                    .flex_shrink_0()
+                    .gap_0p5()
+                    .when(!is_generating && is_estimating, |parent| {
+                        parent
+                            .child(
+                                h_flex()
+                                    .mr_0p5()
+                                    .size_2()
+                                    .justify_center()
+                                    .rounded_full()
+                                    .bg(cx.theme().colors().text.opacity(0.1))
+                                    .child(
+                                        div().size_1().rounded_full().bg(cx.theme().colors().text),
+                                    ),
+                            )
+                            .tooltip(move |window, cx| {
+                                Tooltip::with_meta(
+                                    "Estimated New Token Count",
+                                    None,
+                                    format!(
+                                        "Current Conversation Tokens: {}",
+                                        humanize_token_count(conversation_token_usage.total)
+                                    ),
+                                    window,
+                                    cx,
+                                )
+                            })
+                    })
+                    .child(
+                        Label::new(humanize_token_count(total_token_usage.total))
+                            .size(LabelSize::Small)
+                            .color(token_color)
+                            .map(|label| {
+                                if is_generating || is_waiting_to_update_token_count {
+                                    label
+                                        .with_animation(
+                                            "used-tokens-label",
+                                            Animation::new(Duration::from_secs(2))
+                                                .repeat()
+                                                .with_easing(pulsating_between(0.6, 1.)),
+                                            |label, delta| label.alpha(delta),
+                                        )
+                                        .into_any()
+                                } else {
+                                    label.into_any_element()
+                                }
+                            }),
+                    )
+                    .child(Label::new("/").size(LabelSize::Small).color(Color::Muted))
+                    .child(
+                        Label::new(humanize_token_count(total_token_usage.max))
+                            .size(LabelSize::Small)
+                            .color(Color::Muted),
+                    )
+                    .into_any();
+
+                Some(token_count)
+            }
+            ActiveView::PromptEditor => {
+                let editor = self.context_editor.as_ref()?;
+                let element = render_remaining_tokens(editor, cx)?;
+
+                Some(element.into_any_element())
+            }
+            _ => None,
+        }
+    }
+
    fn render_active_thread_or_empty_state(
        &self,
        window: &mut Window,
@@ -1449,6 +1557,9 @@ impl AssistantPanel {
                    ThreadError::MaxMonthlySpendReached => {
                        self.render_max_monthly_spend_reached_error(cx)
                    }
+                    ThreadError::ModelRequestLimitReached { plan } => {
+                        self.render_model_request_limit_reached_error(plan, cx)
+                    }
                    ThreadError::Message { header, message } => {
                        self.render_error_message(header, message, cx)
                    }
@@ -1551,6 +1662,71 @@ impl AssistantPanel {
            .into_any()
    }

+    fn render_model_request_limit_reached_error(
+        &self,
+        plan: Plan,
+        cx: &mut Context<Self>,
+    ) -> AnyElement {
+        let error_message = match plan {
+            Plan::ZedPro => {
+                "Model request limit reached. Upgrade to usage-based billing for more requests."
+            }
+            Plan::ZedProTrial => {
+                "Model request limit reached. Upgrade to Zed Pro for more requests."
+            }
+            Plan::Free => "Model request limit reached. Upgrade to Zed Pro for more requests.",
+        };
+        let call_to_action = match plan {
+            Plan::ZedPro => "Upgrade to usage-based billing",
+            Plan::ZedProTrial => "Upgrade to Zed Pro",
+            Plan::Free => "Upgrade to Zed Pro",
+        };
+
+        v_flex()
+            .gap_0p5()
+            .child(
+                h_flex()
+                    .gap_1p5()
+                    .items_center()
+                    .child(Icon::new(IconName::XCircle).color(Color::Error))
+                    .child(Label::new("Model Request Limit Reached").weight(FontWeight::MEDIUM)),
+            )
+            .child(
+                div()
+                    .id("error-message")
+                    .max_h_24()
+                    .overflow_y_scroll()
+                    .child(Label::new(error_message)),
+            )
+            .child(
+                h_flex()
+                    .justify_end()
+                    .mt_1()
+                    .child(
+                        Button::new("subscribe", call_to_action).on_click(cx.listener(
+                            |this, _, _, cx| {
+                                this.thread.update(cx, |this, _cx| {
+                                    this.clear_last_error();
+                                });
+
+                                cx.open_url(&zed_urls::account_url(cx));
+                                cx.notify();
+                            },
+                        )),
+                    )
+                    .child(Button::new("dismiss", "Dismiss").on_click(cx.listener(
+                        |this, _, _, cx| {
+                            this.thread.update(cx, |this, _cx| {
+                                this.clear_last_error();
+                            });
+
+                            cx.notify();
+                        },
+                    ))),
+            )
+            .into_any()
+    }
+
    fn render_error_message(
        &self,
        header: SharedString,
@@ -1723,10 +1899,27 @@ impl AssistantPanelDelegate for ConcreteAssistantPanelDelegate {

    fn quote_selection(
        &self,
-        _workspace: &mut Workspace,
-        _creases: Vec<(String, String)>,
-        _window: &mut Window,
-        _cx: &mut Context<Workspace>,
+        workspace: &mut Workspace,
+        creases: Vec<(String, String)>,
+        window: &mut Window,
+        cx: &mut Context<Workspace>,
    ) {
+        let Some(panel) = workspace.panel::<AssistantPanel>(cx) else {
+            return;
+        };
+
+        if !panel.focus_handle(cx).contains_focused(window, cx) {
+            workspace.toggle_panel_focus::<AssistantPanel>(window, cx);
+        }
+
+        panel.update(cx, |_, cx| {
+            // Wait to create a new context until the workspace is no longer
+            // being updated.
+            cx.defer_in(window, move |panel, window, cx| {
+                if let Some(context) = panel.active_context_editor() {
+                    context.update(cx, |context, cx| context.quote_creases(creases, window, cx));
+                };
+            });
+        });
    }
 }
--- a/crates/agent/src/context_picker/completion_provider.rs
+++ b/crates/agent/src/context_picker/completion_provider.rs
@@ -8,6 +8,7 @@ use std::sync::atomic::AtomicBool;
 use anyhow::Result;
 use editor::{CompletionProvider, Editor, ExcerptId};
 use file_icons::FileIcons;
+use fuzzy::{StringMatch, StringMatchCandidate};
 use gpui::{App, Entity, Task, WeakEntity};
 use http_client::HttpClientWithUrl;
 use language::{Buffer, CodeLabel, HighlightId};
@@ -37,7 +38,24 @@ pub(crate) enum Match {
    File(FileMatch),
    Thread(ThreadMatch),
    Fetch(SharedString),
-    Mode(ContextPickerMode),
+    Mode(ModeMatch),
+}
+
+pub struct ModeMatch {
+    mat: Option<StringMatch>,
+    mode: ContextPickerMode,
+}
+
+impl Match {
+    pub fn score(&self) -> f64 {
+        match self {
+            Match::File(file) => file.mat.score,
+            Match::Mode(mode) => mode.mat.as_ref().map(|mat| mat.score).unwrap_or(1.),
+            Match::Thread(_) => 1.,
+            Match::Symbol(_) => 1.,
+            Match::Fetch(_) => 1.,
+        }
+    }
 }

 fn search(
@@ -126,19 +144,54 @@ fn search(
                matches.extend(
                    supported_context_picker_modes(&thread_store)
                        .into_iter()
-                        .map(Match::Mode),
+                        .map(|mode| Match::Mode(ModeMatch { mode, mat: None })),
                );

                Task::ready(matches)
            } else {
+                let executor = cx.background_executor().clone();
+
                let search_files_task =
                    search_files(query.clone(), cancellation_flag.clone(), &workspace, cx);
+
+                let modes = supported_context_picker_modes(&thread_store);
+                let mode_candidates = modes
+                    .iter()
+                    .enumerate()
+                    .map(|(ix, mode)| StringMatchCandidate::new(ix, mode.mention_prefix()))
+                    .collect::<Vec<_>>();
+
                cx.background_spawn(async move {
-                    search_files_task
+                    let mut matches = search_files_task
                        .await
                        .into_iter()
                        .map(Match::File)
-                        .collect()
+                        .collect::<Vec<_>>();
+
+                    let mode_matches = fuzzy::match_strings(
+                        &mode_candidates,
+                        &query,
+                        false,
+                        100,
+                        &Arc::new(AtomicBool::default()),
+                        executor,
+                    )
+                    .await;
+
+                    matches.extend(mode_matches.into_iter().map(|mat| {
+                        Match::Mode(ModeMatch {
+                            mode: modes[mat.candidate_id],
+                            mat: Some(mat),
+                        })
+                    }));
+
+                    matches.sort_by(|a, b| {
+                        b.score()
+                            .partial_cmp(&a.score())
+                            .unwrap_or(std::cmp::Ordering::Equal)
+                    });
+
+                    matches
                })
            }
        }
@@ -548,7 +601,7 @@ impl CompletionProvider for ContextPickerCompletionProvider {
                            context_store.clone(),
                            http_client.clone(),
                        )),
-                        Match::Mode(mode) => {
+                        Match::Mode(ModeMatch { mode, .. }) => {
                            Some(Self::completion_for_mode(source_range.clone(), mode))
                        }
                    })
--- a/crates/agent/src/message_editor.rs
+++ b/crates/agent/src/message_editor.rs
@@ -2,22 +2,23 @@ use std::collections::BTreeMap;
 use std::sync::Arc;

 use crate::assistant_model_selector::ModelType;
+use crate::context::format_context_as_string;
 use crate::tool_compatibility::{IncompatibleToolsState, IncompatibleToolsTooltip};
 use buffer_diff::BufferDiff;
 use collections::HashSet;
 use editor::actions::MoveUp;
 use editor::{
-    ContextMenuOptions, ContextMenuPlacement, Editor, EditorElement, EditorMode, EditorStyle,
-    MultiBuffer,
+    ContextMenuOptions, ContextMenuPlacement, Editor, EditorElement, EditorEvent, EditorMode,
+    EditorStyle, MultiBuffer,
 };
 use file_icons::FileIcons;
 use fs::Fs;
 use gpui::{
-    Animation, AnimationExt, App, Entity, Focusable, Subscription, TextStyle, WeakEntity,
-    linear_color_stop, linear_gradient, point, pulsating_between,
+    Animation, AnimationExt, App, Entity, EventEmitter, Focusable, Subscription, Task, TextStyle,
+    WeakEntity, linear_color_stop, linear_gradient, point, pulsating_between,
 };
 use language::{Buffer, Language};
-use language_model::{ConfiguredModel, LanguageModelRegistry};
+use language_model::{ConfiguredModel, LanguageModelRegistry, LanguageModelRequestMessage};
 use language_model_selector::ToggleModelSelector;
 use multi_buffer;
 use project::Project;
@@ -55,6 +56,8 @@ pub struct MessageEditor {
    edits_expanded: bool,
    editor_is_expanded: bool,
    waiting_for_summaries_to_send: bool,
+    last_estimated_token_count: Option<usize>,
+    update_token_count_task: Option<Task<anyhow::Result<()>>>,
    _subscriptions: Vec<Subscription>,
 }

@@ -129,8 +132,18 @@ impl MessageEditor {
        let incompatible_tools =
            cx.new(|cx| IncompatibleToolsState::new(thread.read(cx).tools().clone(), cx));

-        let subscriptions =
-            vec![cx.subscribe_in(&context_strip, window, Self::handle_context_strip_event)];
+        let subscriptions = vec![
+            cx.subscribe_in(&context_strip, window, Self::handle_context_strip_event),
+            cx.subscribe(&editor, |this, _, event, cx| match event {
+                EditorEvent::BufferEdited => {
+                    this.message_or_context_changed(true, cx);
+                }
+                _ => {}
+            }),
+            cx.observe(&context_store, |this, _, cx| {
+                this.message_or_context_changed(false, cx);
+            }),
+        ];

        Self {
            editor: editor.clone(),
@@ -156,6 +169,8 @@ impl MessageEditor {
            waiting_for_summaries_to_send: false,
            profile_selector: cx
                .new(|cx| ProfileSelector::new(fs, thread_store, editor.focus_handle(cx), cx)),
+            last_estimated_token_count: None,
+            update_token_count_task: None,
            _subscriptions: subscriptions,
        }
    }
@@ -256,6 +271,9 @@ impl MessageEditor {
            text
        });

+        self.last_estimated_token_count.take();
+        cx.emit(MessageEditorEvent::EstimatedTokenCount);
+
        let refresh_task =
            refresh_context_store_text(self.context_store.clone(), &HashSet::default(), cx);

@@ -937,6 +955,80 @@ impl MessageEditor {
                    .label_size(LabelSize::Small),
            )
    }
+
+    pub fn last_estimated_token_count(&self) -> Option<usize> {
+        self.last_estimated_token_count
+    }
+
+    pub fn is_waiting_to_update_token_count(&self) -> bool {
+        self.update_token_count_task.is_some()
+    }
+
+    fn message_or_context_changed(&mut self, debounce: bool, cx: &mut Context<Self>) {
+        cx.emit(MessageEditorEvent::Changed);
+        self.update_token_count_task.take();
+
+        let Some(default_model) = LanguageModelRegistry::read_global(cx).default_model() else {
+            self.last_estimated_token_count.take();
+            return;
+        };
+
+        let context_store = self.context_store.clone();
+        let editor = self.editor.clone();
+        let thread = self.thread.clone();
+
+        self.update_token_count_task = Some(cx.spawn(async move |this, cx| {
+            if debounce {
+                cx.background_executor()
+                    .timer(Duration::from_millis(200))
+                    .await;
+            }
+
+            let token_count = if let Some(task) = cx.update(|cx| {
+                let context = context_store.read(cx).context().iter();
+                let new_context = thread.read(cx).filter_new_context(context);
+                let context_text =
+                    format_context_as_string(new_context, cx).unwrap_or(String::new());
+                let message_text = editor.read(cx).text(cx);
+
+                let content = context_text + &message_text;
+
+                if content.is_empty() {
+                    return None;
+                }
+
+                let request = language_model::LanguageModelRequest {
+                    messages: vec![LanguageModelRequestMessage {
+                        role: language_model::Role::User,
+                        content: vec![content.into()],
+                        cache: false,
+                    }],
+                    tools: vec![],
+                    stop: vec![],
+                    temperature: None,
+                };
+
+                Some(default_model.model.count_tokens(request, cx))
+            })? {
+                task.await?
+            } else {
+                0
+            };
+
+            this.update(cx, |this, cx| {
+                this.last_estimated_token_count = Some(token_count);
+                cx.emit(MessageEditorEvent::EstimatedTokenCount);
+                this.update_token_count_task.take();
+            })
+        }));
+    }
+}
+
+impl EventEmitter<MessageEditorEvent> for MessageEditor {}
+
+pub enum MessageEditorEvent {
+    EstimatedTokenCount,
+    Changed,
 }

 impl Focusable for MessageEditor {
@@ -949,6 +1041,7 @@ impl Render for MessageEditor {
    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
        let thread = self.thread.read(cx);
        let total_token_usage = thread.total_token_usage(cx);
+        let token_usage_ratio = total_token_usage.ratio();

        let action_log = self.thread.read(cx).action_log();
        let changed_buffers = action_log.read(cx).changed_buffers(cx);
@@ -997,15 +1090,8 @@ impl Render for MessageEditor {
                parent.child(self.render_changed_buffers(&changed_buffers, window, cx))
            })
            .child(self.render_editor(font_size, line_height, window, cx))
-            .when(
-                total_token_usage.ratio != TokenUsageRatio::Normal,
-                |parent| {
-                    parent.child(self.render_token_limit_callout(
-                        line_height,
-                        total_token_usage.ratio,
-                        cx,
-                    ))
-                },
-            )
+            .when(token_usage_ratio != TokenUsageRatio::Normal, |parent| {
+                parent.child(self.render_token_limit_callout(line_height, token_usage_ratio, cx))
+            })
    }
 }
--- a/crates/agent/src/thread.rs
+++ b/crates/agent/src/thread.rs
@@ -6,7 +6,7 @@ use std::time::Instant;

 use anyhow::{Context as _, Result, anyhow};
 use assistant_settings::AssistantSettings;
-use assistant_tool::{ActionLog, Tool, ToolWorkingSet};
+use assistant_tool::{ActionLog, AnyToolCard, Tool, ToolWorkingSet};
 use chrono::{DateTime, Utc};
 use collections::{BTreeMap, HashMap};
 use feature_flags::{self, FeatureFlagAppExt};
@@ -18,12 +18,13 @@ use language_model::{
    ConfiguredModel, LanguageModel, LanguageModelCompletionEvent, LanguageModelId,
    LanguageModelKnownError, LanguageModelRegistry, LanguageModelRequest,
    LanguageModelRequestMessage, LanguageModelRequestTool, LanguageModelToolResult,
-    LanguageModelToolUseId, MaxMonthlySpendReachedError, MessageContent, PaymentRequiredError,
-    Role, StopReason, TokenUsage,
+    LanguageModelToolUseId, MaxMonthlySpendReachedError, MessageContent,
+    ModelRequestLimitReachedError, PaymentRequiredError, Role, StopReason, TokenUsage,
 };
 use project::Project;
 use project::git_store::{GitStore, GitStoreCheckpoint, RepositoryState};
 use prompt_store::PromptBuilder;
+use proto::Plan;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::Settings;
@@ -226,7 +227,33 @@ pub enum DetailedSummaryState {
 pub struct TotalTokenUsage {
    pub total: usize,
    pub max: usize,
-    pub ratio: TokenUsageRatio,
+}
+
+impl TotalTokenUsage {
+    pub fn ratio(&self) -> TokenUsageRatio {
+        #[cfg(debug_assertions)]
+        let warning_threshold: f32 = std::env::var("ZED_THREAD_WARNING_THRESHOLD")
+            .unwrap_or("0.8".to_string())
+            .parse()
+            .unwrap();
+        #[cfg(not(debug_assertions))]
+        let warning_threshold: f32 = 0.8;
+
+        if self.total >= self.max {
+            TokenUsageRatio::Exceeded
+        } else if self.total as f32 / self.max as f32 >= warning_threshold {
+            TokenUsageRatio::Warning
+        } else {
+            TokenUsageRatio::Normal
+        }
+    }
+
+    pub fn add(&self, tokens: usize) -> TotalTokenUsage {
+        TotalTokenUsage {
+            total: self.total + tokens,
+            max: self.max,
+        }
+    }
 }

 #[derive(Debug, Default, PartialEq, Eq)]
@@ -260,6 +287,7 @@ pub struct Thread {
    last_restore_checkpoint: Option<LastRestoreCheckpoint>,
    pending_checkpoint: Option<ThreadCheckpoint>,
    initial_project_snapshot: Shared<Task<Option<Arc<ProjectSnapshot>>>>,
+    request_token_usage: Vec<TokenUsage>,
    cumulative_token_usage: TokenUsage,
    exceeded_window_error: Option<ExceededWindowError>,
    feedback: Option<ThreadFeedback>,
@@ -310,6 +338,7 @@ impl Thread {
                    .spawn(async move { Some(project_snapshot.await) })
                    .shared()
            },
+            request_token_usage: Vec::new(),
            cumulative_token_usage: TokenUsage::default(),
            exceeded_window_error: None,
            feedback: None,
@@ -377,6 +406,7 @@ impl Thread {
            tool_use,
            action_log: cx.new(|_| ActionLog::new(project)),
            initial_project_snapshot: Task::ready(serialized.initial_project_snapshot).shared(),
+            request_token_usage: serialized.request_token_usage,
            cumulative_token_usage: serialized.cumulative_token_usage,
            exceeded_window_error: None,
            feedback: None,
@@ -630,10 +660,30 @@ impl Thread {
        self.tool_use.tool_result(id)
    }

+    pub fn output_for_tool(&self, id: &LanguageModelToolUseId) -> Option<&Arc<str>> {
+        Some(&self.tool_use.tool_result(id)?.content)
+    }
+
+    pub fn card_for_tool(&self, id: &LanguageModelToolUseId) -> Option<AnyToolCard> {
+        self.tool_use.tool_result_card(id).cloned()
+    }
+
    pub fn message_has_tool_results(&self, message_id: MessageId) -> bool {
        self.tool_use.message_has_tool_results(message_id)
    }

+    /// Filter out contexts that have already been included in previous messages
+    pub fn filter_new_context<'a>(
+        &self,
+        context: impl Iterator<Item = &'a AssistantContext>,
+    ) -> impl Iterator<Item = &'a AssistantContext> {
+        context.filter(|ctx| self.is_context_new(ctx))
+    }
+
+    fn is_context_new(&self, context: &AssistantContext) -> bool {
+        !self.context.contains_key(&context.id())
+    }
+
    pub fn insert_user_message(
        &mut self,
        text: impl Into<String>,
@@ -645,10 +695,9 @@ impl Thread {

        let message_id = self.insert_message(Role::User, vec![MessageSegment::Text(text)], cx);

-        // Filter out contexts that have already been included in previous messages
        let new_context: Vec<_> = context
            .into_iter()
-            .filter(|ctx| !self.context.contains_key(&ctx.id()))
+            .filter(|ctx| self.is_context_new(ctx))
            .collect();

        if !new_context.is_empty() {
@@ -828,6 +877,7 @@ impl Thread {
                    .collect(),
                initial_project_snapshot,
                cumulative_token_usage: this.cumulative_token_usage,
+                request_token_usage: this.request_token_usage.clone(),
                detailed_summary_state: this.detailed_summary_state.clone(),
                exceeded_window_error: this.exceeded_window_error.clone(),
            })
@@ -1013,7 +1063,6 @@ impl Thread {
        cx: &mut Context<Self>,
    ) {
        let pending_completion_id = post_inc(&mut self.completion_count);
-
        let task = cx.spawn(async move |thread, cx| {
            let stream = model.stream_completion(request, &cx);
            let initial_token_usage =
@@ -1039,6 +1088,7 @@ impl Thread {
                                stop_reason = reason;
                            }
                            LanguageModelCompletionEvent::UsageUpdate(token_usage) => {
+                                thread.update_token_usage_at_last_message(token_usage);
                                thread.cumulative_token_usage = thread.cumulative_token_usage
                                    + token_usage
                                    - current_token_usage;
@@ -1150,6 +1200,12 @@ impl Thread {
                                cx.emit(ThreadEvent::ShowError(
                                    ThreadError::MaxMonthlySpendReached,
                                ));
+                            } else if let Some(error) =
+                                error.downcast_ref::<ModelRequestLimitReachedError>()
+                            {
+                                cx.emit(ThreadEvent::ShowError(
+                                    ThreadError::ModelRequestLimitReached { plan: error.plan },
+                                ));
                            } else if let Some(known_error) =
                                error.downcast_ref::<LanguageModelKnownError>()
                            {
@@ -1419,6 +1475,12 @@ impl Thread {
            )
        };

+        // Store the card separately if it exists
+        if let Some(card) = tool_result.card.clone() {
+            self.tool_use
+                .insert_tool_result_card(tool_use_id.clone(), card);
+        }
+
        cx.spawn({
            async move |thread: WeakEntity<Thread>, cx| {
                let output = tool_result.output.await;
@@ -1801,14 +1863,14 @@ impl Thread {
            .update(cx, |action_log, cx| action_log.keep_all_edits(cx));
    }

-    pub fn reject_edits_in_range(
+    pub fn reject_edits_in_ranges(
        &mut self,
        buffer: Entity<language::Buffer>,
-        buffer_range: Range<language::Anchor>,
+        buffer_ranges: Vec<Range<language::Anchor>>,
        cx: &mut Context<Self>,
    ) -> Task<Result<()>> {
        self.action_log.update(cx, |action_log, cx| {
-            action_log.reject_edits_in_range(buffer, buffer_range, cx)
+            action_log.reject_edits_in_ranges(buffer, buffer_ranges, cx)
        })
    }

@@ -1868,6 +1930,35 @@ impl Thread {
        self.cumulative_token_usage
    }

+    pub fn token_usage_up_to_message(&self, message_id: MessageId, cx: &App) -> TotalTokenUsage {
+        let Some(model) = LanguageModelRegistry::read_global(cx).default_model() else {
+            return TotalTokenUsage::default();
+        };
+
+        let max = model.model.max_token_count();
+
+        let index = self
+            .messages
+            .iter()
+            .position(|msg| msg.id == message_id)
+            .unwrap_or(0);
+
+        if index == 0 {
+            return TotalTokenUsage { total: 0, max };
+        }
+
+        let token_usage = &self
+            .request_token_usage
+            .get(index - 1)
+            .cloned()
+            .unwrap_or_default();
+
+        TotalTokenUsage {
+            total: token_usage.total_tokens() as usize,
+            max,
+        }
+    }
+
    pub fn total_token_usage(&self, cx: &App) -> TotalTokenUsage {
        let model_registry = LanguageModelRegistry::read_global(cx);
        let Some(model) = model_registry.default_model() else {
@@ -1881,30 +1972,33 @@ impl Thread {
                return TotalTokenUsage {
                    total: exceeded_error.token_count,
                    max,
-                    ratio: TokenUsageRatio::Exceeded,
                };
            }
        }

-        #[cfg(debug_assertions)]
-        let warning_threshold: f32 = std::env::var("ZED_THREAD_WARNING_THRESHOLD")
-            .unwrap_or("0.8".to_string())
-            .parse()
-            .unwrap();
-        #[cfg(not(debug_assertions))]
-        let warning_threshold: f32 = 0.8;
+        let total = self
+            .token_usage_at_last_message()
+            .unwrap_or_default()
+            .total_tokens() as usize;

-        let total = self.cumulative_token_usage.total_tokens() as usize;
+        TotalTokenUsage { total, max }
+    }

-        let ratio = if total >= max {
-            TokenUsageRatio::Exceeded
-        } else if total as f32 / max as f32 >= warning_threshold {
-            TokenUsageRatio::Warning
-        } else {
-            TokenUsageRatio::Normal
-        };
+    fn token_usage_at_last_message(&self) -> Option<TokenUsage> {
+        self.request_token_usage
+            .get(self.messages.len().saturating_sub(1))
+            .or_else(|| self.request_token_usage.last())
+            .cloned()
+    }

-        TotalTokenUsage { total, max, ratio }
+    fn update_token_usage_at_last_message(&mut self, token_usage: TokenUsage) {
+        let placeholder = self.token_usage_at_last_message().unwrap_or_default();
+        self.request_token_usage
+            .resize(self.messages.len(), placeholder);
+
+        if let Some(last) = self.request_token_usage.last_mut() {
+            *last = token_usage;
+        }
    }

    pub fn deny_tool_use(
@@ -1929,6 +2023,8 @@ pub enum ThreadError {
    PaymentRequired,
    #[error("Max monthly spend reached")]
    MaxMonthlySpendReached,
+    #[error("Model request limit reached")]
+    ModelRequestLimitReached { plan: Plan },
    #[error("Message {header}: {message}")]
    Message {
        header: SharedString,
--- a/crates/agent/src/thread_store.rs
+++ b/crates/agent/src/thread_store.rs
@@ -509,6 +509,8 @@ pub struct SerializedThread {
    #[serde(default)]
    pub cumulative_token_usage: TokenUsage,
    #[serde(default)]
+    pub request_token_usage: Vec<TokenUsage>,
+    #[serde(default)]
    pub detailed_summary_state: DetailedSummaryState,
    #[serde(default)]
    pub exceeded_window_error: Option<ExceededWindowError>,
@@ -597,6 +599,7 @@ impl LegacySerializedThread {
            messages: self.messages.into_iter().map(|msg| msg.upgrade()).collect(),
            initial_project_snapshot: self.initial_project_snapshot,
            cumulative_token_usage: TokenUsage::default(),
+            request_token_usage: Vec::new(),
            detailed_summary_state: DetailedSummaryState::default(),
            exceeded_window_error: None,
        }
--- a/crates/agent/src/tool_use.rs
+++ b/crates/agent/src/tool_use.rs
@@ -1,7 +1,7 @@
 use std::sync::Arc;

 use anyhow::Result;
-use assistant_tool::{Tool, ToolWorkingSet};
+use assistant_tool::{AnyToolCard, Tool, ToolUseStatus, ToolWorkingSet};
 use collections::HashMap;
 use futures::FutureExt as _;
 use futures::future::Shared;
@@ -27,26 +27,7 @@ pub struct ToolUse {
    pub needs_confirmation: bool,
 }

-#[derive(Debug, Clone)]
-pub enum ToolUseStatus {
-    NeedsConfirmation,
-    Pending,
-    Running,
-    Finished(SharedString),
-    Error(SharedString),
-}
-
-impl ToolUseStatus {
-    pub fn text(&self) -> SharedString {
-        match self {
-            ToolUseStatus::NeedsConfirmation => "".into(),
-            ToolUseStatus::Pending => "".into(),
-            ToolUseStatus::Running => "".into(),
-            ToolUseStatus::Finished(out) => out.clone(),
-            ToolUseStatus::Error(out) => out.clone(),
-        }
-    }
-}
+pub const USING_TOOL_MARKER: &str = "<using_tool>";

 pub struct ToolUseState {
    tools: Entity<ToolWorkingSet>,
@@ -54,10 +35,9 @@ pub struct ToolUseState {
    tool_uses_by_user_message: HashMap<MessageId, Vec<LanguageModelToolUseId>>,
    tool_results: HashMap<LanguageModelToolUseId, LanguageModelToolResult>,
    pending_tool_uses_by_id: HashMap<LanguageModelToolUseId, PendingToolUse>,
+    tool_result_cards: HashMap<LanguageModelToolUseId, AnyToolCard>,
 }

-pub const USING_TOOL_MARKER: &str = "<using_tool>";
-
 impl ToolUseState {
    pub fn new(tools: Entity<ToolWorkingSet>) -> Self {
        Self {
@@ -66,6 +46,7 @@ impl ToolUseState {
            tool_uses_by_user_message: HashMap::default(),
            tool_results: HashMap::default(),
            pending_tool_uses_by_id: HashMap::default(),
+            tool_result_cards: HashMap::default(),
        }
    }

@@ -257,6 +238,18 @@ impl ToolUseState {
        self.tool_results.get(tool_use_id)
    }

+    pub fn tool_result_card(&self, tool_use_id: &LanguageModelToolUseId) -> Option<&AnyToolCard> {
+        self.tool_result_cards.get(tool_use_id)
+    }
+
+    pub fn insert_tool_result_card(
+        &mut self,
+        tool_use_id: LanguageModelToolUseId,
+        card: AnyToolCard,
+    ) {
+        self.tool_result_cards.insert(tool_use_id, card);
+    }
+
    pub fn request_tool_use(
        &mut self,
        assistant_message_id: MessageId,
--- a/crates/agent/src/ui/context_pill.rs
+++ b/crates/agent/src/ui/context_pill.rs
@@ -191,15 +191,12 @@ impl RenderOnce for ContextPill {
            ContextPill::Suggested {
                name,
                icon_path: _,
-                kind,
+                kind: _,
                focused,
                on_click,
            } => base_pill
                .cursor_pointer()
                .pr_1()
-                .when(*focused, |this| {
-                    this.bg(color.element_background.opacity(0.5))
-                })
                .border_dashed()
                .border_color(if *focused {
                    color.border_focused
@@ -207,30 +204,17 @@ impl RenderOnce for ContextPill {
                    color.border
                })
                .hover(|style| style.bg(color.element_hover.opacity(0.5)))
+                .when(*focused, |this| {
+                    this.bg(color.element_background.opacity(0.5))
+                })
                .child(
-                    div().px_0p5().max_w_64().child(
+                    div().max_w_64().child(
                        Label::new(name.clone())
                            .size(LabelSize::Small)
                            .color(Color::Muted)
                            .truncate(),
                    ),
                )
-                .child(
-                    Label::new(match kind {
-                        ContextKind::File => "Active Tab",
-                        ContextKind::Thread
-                        | ContextKind::Directory
-                        | ContextKind::FetchedUrl
-                        | ContextKind::Symbol => "Active",
-                    })
-                    .size(LabelSize::XSmall)
-                    .color(Color::Muted),
-                )
-                .child(
-                    Icon::new(IconName::Plus)
-                        .size(IconSize::XSmall)
-                        .into_any_element(),
-                )
                .tooltip(|window, cx| {
                    Tooltip::with_meta("Suggested Context", None, "Click to add it", window, cx)
                })
--- a/crates/askpass/Cargo.toml
+++ b/crates/askpass/Cargo.toml
@@ -18,5 +18,4 @@ gpui.workspace = true
 smol.workspace = true
 tempfile.workspace = true
 util.workspace = true
-which.workspace = true
 workspace-hack.workspace = true
--- a/crates/askpass/src/askpass.rs
+++ b/crates/askpass/src/askpass.rs
@@ -72,6 +72,8 @@ impl AskPassSession {
        let (askpass_opened_tx, askpass_opened_rx) = oneshot::channel::<()>();
        let listener =
            UnixListener::bind(&askpass_socket).context("failed to create askpass socket")?;
+        let zed_path = std::env::current_exe()
+            .context("Failed to figure out current executable path for use in askpass")?;

        let (askpass_kill_master_tx, askpass_kill_master_rx) = oneshot::channel::<()>();
        let mut kill_tx = Some(askpass_kill_master_tx);
@@ -110,21 +112,10 @@ impl AskPassSession {
            drop(temp_dir)
        });

-        anyhow::ensure!(
-            which::which("nc").is_ok(),
-            "Cannot find `nc` command (netcat), which is required to connect over SSH."
-        );
-
        // Create an askpass script that communicates back to this process.
        let askpass_script = format!(
-            "{shebang}\n{print_args} | {nc} -U {askpass_socket} 2> /dev/null \n",
-            // on macOS `brew install netcat` provides the GNU netcat implementation
-            // which does not support -U.
-            nc = if cfg!(target_os = "macos") {
-                "/usr/bin/nc"
-            } else {
-                "nc"
-            },
+            "{shebang}\n{print_args} | {zed_exe} --askpass={askpass_socket} 2> /dev/null \n",
+            zed_exe = zed_path.display(),
            askpass_socket = askpass_socket.display(),
            print_args = "printf '%s\\0' \"$@\"",
            shebang = "#!/bin/sh",
@@ -170,6 +161,51 @@ impl AskPassSession {
    }
 }

+/// The main function for when Zed is running in netcat mode for use in askpass.
+/// Called from both the remote server binary and the zed binary in their respective main functions.
+#[cfg(unix)]
+pub fn main(socket: &str) {
+    use std::io::{self, Read, Write};
+    use std::os::unix::net::UnixStream;
+    use std::process::exit;
+
+    let mut stream = match UnixStream::connect(socket) {
+        Ok(stream) => stream,
+        Err(err) => {
+            eprintln!("Error connecting to socket {}: {}", socket, err);
+            exit(1);
+        }
+    };
+
+    let mut buffer = Vec::new();
+    if let Err(err) = io::stdin().read_to_end(&mut buffer) {
+        eprintln!("Error reading from stdin: {}", err);
+        exit(1);
+    }
+
+    if buffer.last() != Some(&b'\0') {
+        buffer.push(b'\0');
+    }
+
+    if let Err(err) = stream.write_all(&buffer) {
+        eprintln!("Error writing to socket: {}", err);
+        exit(1);
+    }
+
+    let mut response = Vec::new();
+    if let Err(err) = stream.read_to_end(&mut response) {
+        eprintln!("Error reading from socket: {}", err);
+        exit(1);
+    }
+
+    if let Err(err) = io::stdout().write_all(&response) {
+        eprintln!("Error writing to stdout: {}", err);
+        exit(1);
+    }
+}
+#[cfg(not(unix))]
+pub fn main(_socket: &str) {}
+
 #[cfg(not(unix))]
 pub struct AskPassSession {
    path: PathBuf,
--- a/crates/assistant_tool/src/action_log.rs
+++ b/crates/assistant_tool/src/action_log.rs
@@ -3,7 +3,7 @@ use buffer_diff::BufferDiff;
 use collections::BTreeMap;
 use futures::{StreamExt, channel::mpsc};
 use gpui::{App, AppContext, AsyncApp, Context, Entity, Subscription, Task, WeakEntity};
-use language::{Anchor, Buffer, BufferEvent, DiskState, Point};
+use language::{Anchor, Buffer, BufferEvent, DiskState, Point, ToPoint};
 use project::{Project, ProjectItem, lsp_store::OpenLspBufferHandle};
 use std::{cmp, ops::Range, sync::Arc};
 use text::{Edit, Patch, Rope};
@@ -363,10 +363,10 @@ impl ActionLog {
        }
    }

-    pub fn reject_edits_in_range(
+    pub fn reject_edits_in_ranges(
        &mut self,
        buffer: Entity<Buffer>,
-        buffer_range: Range<impl language::ToPoint>,
+        buffer_ranges: Vec<Range<impl language::ToPoint>>,
        cx: &mut Context<Self>,
    ) -> Task<Result<()>> {
        let Some(tracked_buffer) = self.tracked_buffers.get_mut(&buffer) else {
@@ -403,29 +403,15 @@ impl ActionLog {
            }
            TrackedBufferStatus::Modified => {
                buffer.update(cx, |buffer, cx| {
-                    let buffer_range =
-                        buffer_range.start.to_point(buffer)..buffer_range.end.to_point(buffer);
+                    let mut buffer_row_ranges = buffer_ranges
+                        .into_iter()
+                        .map(|range| {
+                            range.start.to_point(buffer).row..range.end.to_point(buffer).row
+                        })
+                        .peekable();

                    let mut edits_to_revert = Vec::new();
                    for edit in tracked_buffer.unreviewed_changes.edits() {
-                        if buffer_range.end.row < edit.new.start {
-                            break;
-                        } else if buffer_range.start.row > edit.new.end {
-                            continue;
-                        }
-
-                        let old_range = tracked_buffer
-                            .base_text
-                            .point_to_offset(Point::new(edit.old.start, 0))
-                            ..tracked_buffer.base_text.point_to_offset(cmp::min(
-                                Point::new(edit.old.end, 0),
-                                tracked_buffer.base_text.max_point(),
-                            ));
-                        let old_text = tracked_buffer
-                            .base_text
-                            .chunks_in_range(old_range)
-                            .collect::<String>();
-
                        let new_range = tracked_buffer
                            .snapshot
                            .anchor_before(Point::new(edit.new.start, 0))
@@ -433,7 +419,35 @@ impl ActionLog {
                                Point::new(edit.new.end, 0),
                                tracked_buffer.snapshot.max_point(),
                            ));
-                        edits_to_revert.push((new_range, old_text));
+                        let new_row_range = new_range.start.to_point(buffer).row
+                            ..new_range.end.to_point(buffer).row;
+
+                        let mut revert = false;
+                        while let Some(buffer_row_range) = buffer_row_ranges.peek() {
+                            if buffer_row_range.end < new_row_range.start {
+                                buffer_row_ranges.next();
+                            } else if buffer_row_range.start > new_row_range.end {
+                                break;
+                            } else {
+                                revert = true;
+                                break;
+                            }
+                        }
+
+                        if revert {
+                            let old_range = tracked_buffer
+                                .base_text
+                                .point_to_offset(Point::new(edit.old.start, 0))
+                                ..tracked_buffer.base_text.point_to_offset(cmp::min(
+                                    Point::new(edit.old.end, 0),
+                                    tracked_buffer.base_text.max_point(),
+                                ));
+                            let old_text = tracked_buffer
+                                .base_text
+                                .chunks_in_range(old_range)
+                                .collect::<String>();
+                            edits_to_revert.push((new_range, old_text));
+                        }
                    }

                    buffer.edit(edits_to_revert, None, cx);
@@ -599,6 +613,7 @@ fn point_to_row_edit(edit: Edit<Point>, old_text: &Rope, new_text: &Rope) -> Edi
    }
 }

+#[derive(Copy, Clone, Debug)]
 enum ChangeAuthor {
    User,
    Agent,
@@ -1135,9 +1150,48 @@ mod tests {
            )]
        );

+        // If the rejected range doesn't overlap with any hunk, we ignore it.
        action_log
            .update(cx, |log, cx| {
-                log.reject_edits_in_range(buffer.clone(), Point::new(0, 0)..Point::new(1, 0), cx)
+                log.reject_edits_in_ranges(
+                    buffer.clone(),
+                    vec![Point::new(4, 0)..Point::new(4, 0)],
+                    cx,
+                )
+            })
+            .await
+            .unwrap();
+        cx.run_until_parked();
+        assert_eq!(
+            buffer.read_with(cx, |buffer, _| buffer.text()),
+            "abc\ndE\nXYZf\nghi\njkl\nmnO"
+        );
+        assert_eq!(
+            unreviewed_hunks(&action_log, cx),
+            vec![(
+                buffer.clone(),
+                vec![
+                    HunkStatus {
+                        range: Point::new(1, 0)..Point::new(3, 0),
+                        diff_status: DiffHunkStatusKind::Modified,
+                        old_text: "def\n".into(),
+                    },
+                    HunkStatus {
+                        range: Point::new(5, 0)..Point::new(5, 3),
+                        diff_status: DiffHunkStatusKind::Modified,
+                        old_text: "mno".into(),
+                    }
+                ],
+            )]
+        );
+
+        action_log
+            .update(cx, |log, cx| {
+                log.reject_edits_in_ranges(
+                    buffer.clone(),
+                    vec![Point::new(0, 0)..Point::new(1, 0)],
+                    cx,
+                )
            })
            .await
            .unwrap();
@@ -1160,7 +1214,11 @@ mod tests {

        action_log
            .update(cx, |log, cx| {
-                log.reject_edits_in_range(buffer.clone(), Point::new(4, 0)..Point::new(4, 0), cx)
+                log.reject_edits_in_ranges(
+                    buffer.clone(),
+                    vec![Point::new(4, 0)..Point::new(4, 0)],
+                    cx,
+                )
            })
            .await
            .unwrap();
@@ -1172,6 +1230,82 @@ mod tests {
        assert_eq!(unreviewed_hunks(&action_log, cx), vec![]);
    }

+    #[gpui::test(iterations = 10)]
+    async fn test_reject_multiple_edits(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(path!("/dir"), json!({"file": "abc\ndef\nghi\njkl\nmno"}))
+            .await;
+        let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
+        let file_path = project
+            .read_with(cx, |project, cx| project.find_project_path("dir/file", cx))
+            .unwrap();
+        let buffer = project
+            .update(cx, |project, cx| project.open_buffer(file_path, cx))
+            .await
+            .unwrap();
+
+        cx.update(|cx| {
+            action_log.update(cx, |log, cx| log.buffer_read(buffer.clone(), cx));
+            buffer.update(cx, |buffer, cx| {
+                buffer
+                    .edit([(Point::new(1, 1)..Point::new(1, 2), "E\nXYZ")], None, cx)
+                    .unwrap()
+            });
+            buffer.update(cx, |buffer, cx| {
+                buffer
+                    .edit([(Point::new(5, 2)..Point::new(5, 3), "O")], None, cx)
+                    .unwrap()
+            });
+            action_log.update(cx, |log, cx| log.buffer_edited(buffer.clone(), cx));
+        });
+        cx.run_until_parked();
+        assert_eq!(
+            buffer.read_with(cx, |buffer, _| buffer.text()),
+            "abc\ndE\nXYZf\nghi\njkl\nmnO"
+        );
+        assert_eq!(
+            unreviewed_hunks(&action_log, cx),
+            vec![(
+                buffer.clone(),
+                vec![
+                    HunkStatus {
+                        range: Point::new(1, 0)..Point::new(3, 0),
+                        diff_status: DiffHunkStatusKind::Modified,
+                        old_text: "def\n".into(),
+                    },
+                    HunkStatus {
+                        range: Point::new(5, 0)..Point::new(5, 3),
+                        diff_status: DiffHunkStatusKind::Modified,
+                        old_text: "mno".into(),
+                    }
+                ],
+            )]
+        );
+
+        action_log.update(cx, |log, cx| {
+            let range_1 = buffer.read(cx).anchor_before(Point::new(0, 0))
+                ..buffer.read(cx).anchor_before(Point::new(1, 0));
+            let range_2 = buffer.read(cx).anchor_before(Point::new(5, 0))
+                ..buffer.read(cx).anchor_before(Point::new(5, 3));
+
+            log.reject_edits_in_ranges(buffer.clone(), vec![range_1, range_2], cx)
+                .detach();
+            assert_eq!(
+                buffer.read_with(cx, |buffer, _| buffer.text()),
+                "abc\ndef\nghi\njkl\nmno"
+            );
+        });
+        cx.run_until_parked();
+        assert_eq!(
+            buffer.read_with(cx, |buffer, _| buffer.text()),
+            "abc\ndef\nghi\njkl\nmno"
+        );
+        assert_eq!(unreviewed_hunks(&action_log, cx), vec![]);
+    }
+
    #[gpui::test(iterations = 10)]
    async fn test_reject_deleted_file(cx: &mut TestAppContext) {
        init_test(cx);
@@ -1215,7 +1349,11 @@ mod tests {

        action_log
            .update(cx, |log, cx| {
-                log.reject_edits_in_range(buffer.clone(), Point::new(0, 0)..Point::new(0, 0), cx)
+                log.reject_edits_in_ranges(
+                    buffer.clone(),
+                    vec![Point::new(0, 0)..Point::new(0, 0)],
+                    cx,
+                )
            })
            .await
            .unwrap();
@@ -1266,7 +1404,11 @@ mod tests {

        action_log
            .update(cx, |log, cx| {
-                log.reject_edits_in_range(buffer.clone(), Point::new(0, 0)..Point::new(0, 11), cx)
+                log.reject_edits_in_ranges(
+                    buffer.clone(),
+                    vec![Point::new(0, 0)..Point::new(0, 11)],
+                    cx,
+                )
            })
            .await
            .unwrap();
@@ -1312,7 +1454,7 @@ mod tests {
                        .update(cx, |log, cx| {
                            let range = buffer.read(cx).random_byte_range(0, &mut rng);
                            log::info!("rejecting edits in range {:?}", range);
-                            log.reject_edits_in_range(buffer.clone(), range, cx)
+                            log.reject_edits_in_ranges(buffer.clone(), vec![range], cx)
                        })
                        .await
                        .unwrap();
--- a/crates/assistant_tool/src/assistant_tool.rs
+++ b/crates/assistant_tool/src/assistant_tool.rs
@@ -9,6 +9,10 @@ use std::fmt::Formatter;
 use std::sync::Arc;

 use anyhow::Result;
+use gpui::AnyElement;
+use gpui::Context;
+use gpui::IntoElement;
+use gpui::Window;
 use gpui::{App, Entity, SharedString, Task};
 use icons::IconName;
 use language_model::LanguageModelRequestMessage;
@@ -24,16 +28,87 @@ pub fn init(cx: &mut App) {
    ToolRegistry::default_global(cx);
 }

-/// The result of running a tool
+#[derive(Debug, Clone)]
+pub enum ToolUseStatus {
+    NeedsConfirmation,
+    Pending,
+    Running,
+    Finished(SharedString),
+    Error(SharedString),
+}
+
+impl ToolUseStatus {
+    pub fn text(&self) -> SharedString {
+        match self {
+            ToolUseStatus::NeedsConfirmation => "".into(),
+            ToolUseStatus::Pending => "".into(),
+            ToolUseStatus::Running => "".into(),
+            ToolUseStatus::Finished(out) => out.clone(),
+            ToolUseStatus::Error(out) => out.clone(),
+        }
+    }
+}
+
+/// The result of running a tool, containing both the asynchronous output
+/// and an optional card view that can be rendered immediately.
 pub struct ToolResult {
    /// The asynchronous task that will eventually resolve to the tool's output
    pub output: Task<Result<String>>,
+    /// An optional view to present the output of the tool.
+    pub card: Option<AnyToolCard>,
+}
+
+pub trait ToolCard: 'static + Sized {
+    fn render(
+        &mut self,
+        status: &ToolUseStatus,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> impl IntoElement;
+}
+
+#[derive(Clone)]
+pub struct AnyToolCard {
+    entity: gpui::AnyEntity,
+    render: fn(
+        entity: gpui::AnyEntity,
+        status: &ToolUseStatus,
+        window: &mut Window,
+        cx: &mut App,
+    ) -> AnyElement,
+}
+
+impl<T: ToolCard> From<Entity<T>> for AnyToolCard {
+    fn from(entity: Entity<T>) -> Self {
+        fn downcast_render<T: ToolCard>(
+            entity: gpui::AnyEntity,
+            status: &ToolUseStatus,
+            window: &mut Window,
+            cx: &mut App,
+        ) -> AnyElement {
+            let entity = entity.downcast::<T>().unwrap();
+            entity.update(cx, |entity, cx| {
+                entity.render(status, window, cx).into_any_element()
+            })
+        }
+
+        Self {
+            entity: entity.into(),
+            render: downcast_render::<T>,
+        }
+    }
+}
+
+impl AnyToolCard {
+    pub fn render(&self, status: &ToolUseStatus, window: &mut Window, cx: &mut App) -> AnyElement {
+        (self.render)(self.entity.clone(), status, window, cx)
+    }
 }

 impl From<Task<Result<String>>> for ToolResult {
-    /// Convert from a task to a ToolResult
+    /// Convert from a task to a ToolResult with no card
    fn from(output: Task<Result<String>>) -> Self {
-        Self { output }
+        Self { output, card: None }
    }
 }

--- a/crates/assistant_tools/Cargo.toml
+++ b/crates/assistant_tools/Cargo.toml
@@ -16,6 +16,7 @@ anyhow.workspace = true
 assistant_tool.workspace = true
 chrono.workspace = true
 collections.workspace = true
+feature_flags.workspace = true
 futures.workspace = true
 gpui.workspace = true
 html_to_markdown.workspace = true
@@ -32,7 +33,9 @@ ui.workspace = true
 util.workspace = true
 worktree.workspace = true
 open = { workspace = true }
+web_search.workspace = true
 workspace-hack.workspace = true
+zed_llm_client.workspace = true

 [dev-dependencies]
 collections = { workspace = true, features = ["test-support"] }
--- a/crates/assistant_tools/src/assistant_tools.rs
+++ b/crates/assistant_tools/src/assistant_tools.rs
@@ -22,14 +22,17 @@ mod schema;
 mod symbol_info_tool;
 mod terminal_tool;
 mod thinking_tool;
+mod web_search_tool;

 use std::sync::Arc;

 use assistant_tool::ToolRegistry;
 use copy_path_tool::CopyPathTool;
+use feature_flags::FeatureFlagAppExt;
 use gpui::App;
 use http_client::HttpClientWithUrl;
 use move_path_tool::MovePathTool;
+use web_search_tool::WebSearchTool;

 use crate::batch_tool::BatchTool;
 use crate::code_action_tool::CodeActionTool;
@@ -56,28 +59,39 @@ pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut App) {
    assistant_tool::init(cx);

    let registry = ToolRegistry::global(cx);
-    registry.register_tool(TerminalTool);
    registry.register_tool(BatchTool);
-    registry.register_tool(CreateDirectoryTool);
-    registry.register_tool(CreateFileTool);
-    registry.register_tool(CopyPathTool);
-    registry.register_tool(DeletePathTool);
-    registry.register_tool(FindReplaceFileTool);
-    registry.register_tool(SymbolInfoTool);
    registry.register_tool(CodeActionTool);
-    registry.register_tool(MovePathTool);
-    registry.register_tool(DiagnosticsTool);
-    registry.register_tool(ListDirectoryTool);
-    registry.register_tool(NowTool);
-    registry.register_tool(OpenTool);
    registry.register_tool(CodeSymbolsTool);
    registry.register_tool(ContentsTool);
+    registry.register_tool(CopyPathTool);
+    registry.register_tool(CreateDirectoryTool);
+    registry.register_tool(CreateFileTool);
+    registry.register_tool(DeletePathTool);
+    registry.register_tool(DiagnosticsTool);
+    registry.register_tool(FetchTool::new(http_client));
+    registry.register_tool(FindReplaceFileTool);
+    registry.register_tool(ListDirectoryTool);
+    registry.register_tool(MovePathTool);
+    registry.register_tool(NowTool);
+    registry.register_tool(OpenTool);
    registry.register_tool(PathSearchTool);
    registry.register_tool(ReadFileTool);
    registry.register_tool(RegexSearchTool);
    registry.register_tool(RenameTool);
+    registry.register_tool(SymbolInfoTool);
+    registry.register_tool(TerminalTool);
    registry.register_tool(ThinkingTool);
-    registry.register_tool(FetchTool::new(http_client));
+
+    cx.observe_flag::<feature_flags::ZedProWebSearchTool, _>({
+        move |is_enabled, cx| {
+            if is_enabled {
+                ToolRegistry::global(cx).register_tool(WebSearchTool);
+            } else {
+                ToolRegistry::global(cx).unregister_tool(WebSearchTool);
+            }
+        }
+    })
+    .detach();
 }

 #[cfg(test)]
--- a/crates/assistant_tools/src/web_search_tool.rs
+++ b/crates/assistant_tools/src/web_search_tool.rs
@@ -0,0 +1,213 @@
+use std::{sync::Arc, time::Duration};
+
+use crate::schema::json_schema_for;
+use anyhow::{Context as _, Result, anyhow};
+use assistant_tool::{ActionLog, Tool, ToolCard, ToolResult, ToolUseStatus};
+use futures::{FutureExt, TryFutureExt};
+use gpui::{
+    Animation, AnimationExt, App, AppContext, Context, Entity, IntoElement, Task, Window,
+    pulsating_between,
+};
+use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
+use project::Project;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use ui::{IconName, Tooltip, prelude::*};
+use web_search::WebSearchRegistry;
+use zed_llm_client::WebSearchResponse;
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct WebSearchToolInput {
+    /// The search term or question to query on the web.
+    query: String,
+}
+
+pub struct WebSearchTool;
+
+impl Tool for WebSearchTool {
+    fn name(&self) -> String {
+        "web_search".into()
+    }
+
+    fn needs_confirmation(&self, _: &serde_json::Value, _: &App) -> bool {
+        false
+    }
+
+    fn description(&self) -> String {
+        "Search the web for information using your query. Use this when you need real-time information, facts, or data that might not be in your training. Results will include snippets and links from relevant web pages.".into()
+    }
+
+    fn icon(&self) -> IconName {
+        IconName::Globe
+    }
+
+    fn input_schema(&self, format: LanguageModelToolSchemaFormat) -> Result<serde_json::Value> {
+        json_schema_for::<WebSearchToolInput>(format)
+    }
+
+    fn ui_text(&self, _input: &serde_json::Value) -> String {
+        "Web Search".to_string()
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: serde_json::Value,
+        _messages: &[LanguageModelRequestMessage],
+        _project: Entity<Project>,
+        _action_log: Entity<ActionLog>,
+        cx: &mut App,
+    ) -> ToolResult {
+        let input = match serde_json::from_value::<WebSearchToolInput>(input) {
+            Ok(input) => input,
+            Err(err) => return Task::ready(Err(anyhow!(err))).into(),
+        };
+        let Some(provider) = WebSearchRegistry::read_global(cx).active_provider() else {
+            return Task::ready(Err(anyhow!("Web search is not available."))).into();
+        };
+
+        let search_task = provider.search(input.query, cx).map_err(Arc::new).shared();
+        let output = cx.background_spawn({
+            let search_task = search_task.clone();
+            async move {
+                let response = search_task.await.map_err(|err| anyhow!(err))?;
+                serde_json::to_string(&response).context("Failed to serialize search results")
+            }
+        });
+
+        ToolResult {
+            output,
+            card: Some(cx.new(|cx| WebSearchToolCard::new(search_task, cx)).into()),
+        }
+    }
+}
+
+struct WebSearchToolCard {
+    response: Option<Result<WebSearchResponse>>,
+    _task: Task<()>,
+}
+
+impl WebSearchToolCard {
+    fn new(
+        search_task: impl 'static + Future<Output = Result<WebSearchResponse, Arc<anyhow::Error>>>,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let _task = cx.spawn(async move |this, cx| {
+            let response = search_task.await.map_err(|err| anyhow!(err));
+            this.update(cx, |this, cx| {
+                this.response = Some(response);
+                cx.notify();
+            })
+            .ok();
+        });
+
+        Self {
+            response: None,
+            _task,
+        }
+    }
+}
+
+impl ToolCard for WebSearchToolCard {
+    fn render(
+        &mut self,
+        _status: &ToolUseStatus,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> impl IntoElement {
+        let header = h_flex()
+            .id("tool-label-container")
+            .gap_1p5()
+            .max_w_full()
+            .overflow_x_scroll()
+            .child(
+                Icon::new(IconName::Globe)
+                    .size(IconSize::XSmall)
+                    .color(Color::Muted),
+            )
+            .child(match self.response.as_ref() {
+                Some(Ok(response)) => {
+                    let text: SharedString = if response.citations.len() == 1 {
+                        "1 result".into()
+                    } else {
+                        format!("{} results", response.citations.len()).into()
+                    };
+                    h_flex()
+                        .gap_1p5()
+                        .child(Label::new("Searched the Web").size(LabelSize::Small))
+                        .child(
+                            div()
+                                .size(px(3.))
+                                .rounded_full()
+                                .bg(cx.theme().colors().text),
+                        )
+                        .child(Label::new(text).size(LabelSize::Small))
+                        .into_any_element()
+                }
+                Some(Err(error)) => div()
+                    .id("web-search-error")
+                    .child(Label::new("Web Search failed").size(LabelSize::Small))
+                    .tooltip(Tooltip::text(error.to_string()))
+                    .into_any_element(),
+
+                None => Label::new("Searching the Web…")
+                    .size(LabelSize::Small)
+                    .with_animation(
+                        "web-search-label",
+                        Animation::new(Duration::from_secs(2))
+                            .repeat()
+                            .with_easing(pulsating_between(0.6, 1.)),
+                        |label, delta| label.alpha(delta),
+                    )
+                    .into_any_element(),
+            })
+            .into_any();
+
+        let content =
+            self.response.as_ref().and_then(|response| match response {
+                Ok(response) => {
+                    Some(
+                        v_flex()
+                            .ml_1p5()
+                            .pl_1p5()
+                            .border_l_1()
+                            .border_color(cx.theme().colors().border_variant)
+                            .gap_1()
+                            .children(response.citations.iter().enumerate().map(
+                                |(index, citation)| {
+                                    let title = citation.title.clone();
+                                    let url = citation.url.clone();
+
+                                    Button::new(("citation", index), title)
+                                        .label_size(LabelSize::Small)
+                                        .color(Color::Muted)
+                                        .icon(IconName::ArrowUpRight)
+                                        .icon_size(IconSize::XSmall)
+                                        .icon_position(IconPosition::End)
+                                        .truncate(true)
+                                        .tooltip({
+                                            let url = url.clone();
+                                            move |window, cx| {
+                                                Tooltip::with_meta(
+                                                    "Citation Link",
+                                                    None,
+                                                    url.clone(),
+                                                    window,
+                                                    cx,
+                                                )
+                                            }
+                                        })
+                                        .on_click({
+                                            let url = url.clone();
+                                            move |_, _, cx| cx.open_url(&url)
+                                        })
+                                },
+                            ))
+                            .into_any(),
+                    )
+                }
+                Err(_) => None,
+            });
+
+        v_flex().my_2().gap_1().child(header).children(content)
+    }
+}
--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -75,6 +75,7 @@ tracing-subscriber = { version = "0.3.18", features = ["env-filter", "json", "re
 util.workspace = true
 uuid.workspace = true
 workspace-hack.workspace = true
+zed_llm_client.workspace = true

 [dev-dependencies]
 assistant = { workspace = true, features = ["test-support"] }
--- a/crates/collab/migrations_llm/20250415213005_add_subscription_usages.sql
+++ b/crates/collab/migrations_llm/20250415213005_add_subscription_usages.sql
@@ -0,0 +1,10 @@
+create table subscription_usages (
+    id serial primary key,
+    user_id integer not null,
+    period_start_at timestamp without time zone not null,
+    period_end_at timestamp without time zone not null,
+    model_requests int not null default 0,
+    edit_predictions int not null default 0
+);
+
+create unique index uix_subscription_usages_on_user_id_start_at_end_at on subscription_usages (user_id, period_start_at, period_end_at);
--- a/crates/collab/migrations_llm/20250416181354_add_plan_to_subscription_usages.sql
+++ b/crates/collab/migrations_llm/20250416181354_add_plan_to_subscription_usages.sql
@@ -0,0 +1,4 @@
+alter table subscription_usages
+    add column plan text not null;
+
+create index ix_subscription_usages_on_plan on subscription_usages (plan);
--- a/crates/collab/src/api/billing.rs
+++ b/crates/collab/src/api/billing.rs
@@ -15,10 +15,12 @@ use stripe::{
    BillingPortalSession, CancellationDetailsReason, CreateBillingPortalSession,
    CreateBillingPortalSessionFlowData, CreateBillingPortalSessionFlowDataAfterCompletion,
    CreateBillingPortalSessionFlowDataAfterCompletionRedirect,
+    CreateBillingPortalSessionFlowDataSubscriptionUpdateConfirm,
+    CreateBillingPortalSessionFlowDataSubscriptionUpdateConfirmItems,
    CreateBillingPortalSessionFlowDataType, CreateCustomer, Customer, CustomerId, EventObject,
    EventType, Expandable, ListEvents, Subscription, SubscriptionId, SubscriptionStatus,
 };
-use util::ResultExt;
+use util::{ResultExt, maybe};

 use crate::api::events::SnowflakeRow;
 use crate::db::billing_subscription::{
@@ -52,6 +54,7 @@ pub fn router() -> Router {
            post(manage_billing_subscription),
        )
        .route("/billing/monthly_spend", get(get_monthly_spend))
+        .route("/billing/usage", get(get_current_usage))
 }

 #[derive(Debug, Deserialize)]
@@ -159,6 +162,7 @@ struct BillingSubscriptionJson {
    id: BillingSubscriptionId,
    name: String,
    status: StripeSubscriptionStatus,
+    trial_end_at: Option<String>,
    cancel_at: Option<String>,
    /// Whether this subscription can be canceled.
    is_cancelable: bool,
@@ -188,9 +192,21 @@ async fn list_billing_subscriptions(
                id: subscription.id,
                name: match subscription.kind {
                    Some(SubscriptionKind::ZedPro) => "Zed Pro".to_string(),
+                    Some(SubscriptionKind::ZedProTrial) => "Zed Pro (Trial)".to_string(),
+                    Some(SubscriptionKind::ZedFree) => "Zed Free".to_string(),
                    None => "Zed LLM Usage".to_string(),
                },
                status: subscription.stripe_subscription_status,
+                trial_end_at: if subscription.kind == Some(SubscriptionKind::ZedProTrial) {
+                    maybe!({
+                        let end_at = subscription.stripe_current_period_end?;
+                        let end_at = DateTime::from_timestamp(end_at, 0)?;
+
+                        Some(end_at.to_rfc3339_opts(SecondsFormat::Millis, true))
+                    })
+                } else {
+                    None
+                },
                cancel_at: subscription.stripe_cancel_at.map(|cancel_at| {
                    cancel_at
                        .and_utc()
@@ -207,6 +223,7 @@ async fn list_billing_subscriptions(
 #[serde(rename_all = "snake_case")]
 enum ProductCode {
    ZedPro,
+    ZedProTrial,
 }

 #[derive(Debug, Deserialize)]
@@ -286,24 +303,38 @@ async fn create_billing_subscription(
        customer.id
    };

+    let success_url = format!(
+        "{}/account?checkout_complete=1",
+        app.config.zed_dot_dev_url()
+    );
+
    let checkout_session_url = match body.product {
        Some(ProductCode::ZedPro) => {
-            let success_url = format!(
-                "{}/account?checkout_complete=1",
-                app.config.zed_dot_dev_url()
-            );
            stripe_billing
-                .checkout_with_zed_pro(customer_id, &user.github_login, &success_url)
+                .checkout_with_price(
+                    app.config.zed_pro_price_id()?,
+                    customer_id,
+                    &user.github_login,
+                    &success_url,
+                )
+                .await?
+        }
+        Some(ProductCode::ZedProTrial) => {
+            stripe_billing
+                .checkout_with_price(
+                    app.config.zed_pro_trial_price_id()?,
+                    customer_id,
+                    &user.github_login,
+                    &success_url,
+                )
                .await?
        }
        None => {
-            let default_model =
-                llm_db.model(rpc::LanguageModelProvider::Anthropic, "claude-3-7-sonnet")?;
+            let default_model = llm_db.model(
+                zed_llm_client::LanguageModelProvider::Anthropic,
+                "claude-3-7-sonnet",
+            )?;
            let stripe_model = stripe_billing.register_model(default_model).await?;
-            let success_url = format!(
-                "{}/account?checkout_complete=1",
-                app.config.zed_dot_dev_url()
-            );
            stripe_billing
                .checkout(customer_id, &user.github_login, &stripe_model, &success_url)
                .await?
@@ -322,6 +353,8 @@ enum ManageSubscriptionIntent {
    ///
    /// This will open the Stripe billing portal without putting the user in a specific flow.
    ManageSubscription,
+    /// The user intends to upgrade to Zed Pro.
+    UpgradeToPro,
    /// The user intends to cancel their subscription.
    Cancel,
    /// The user intends to stop the cancellation of their subscription.
@@ -373,11 +406,10 @@ async fn manage_billing_subscription(
        .get_billing_subscription_by_id(body.subscription_id)
        .await?
        .ok_or_else(|| anyhow!("subscription not found"))?;
+    let subscription_id = SubscriptionId::from_str(&subscription.stripe_subscription_id)
+        .context("failed to parse subscription ID")?;

    if body.intent == ManageSubscriptionIntent::StopCancellation {
-        let subscription_id = SubscriptionId::from_str(&subscription.stripe_subscription_id)
-            .context("failed to parse subscription ID")?;
-
        let updated_stripe_subscription = Subscription::update(
            &stripe_client,
            &subscription_id,
@@ -410,6 +442,47 @@ async fn manage_billing_subscription(

    let flow = match body.intent {
        ManageSubscriptionIntent::ManageSubscription => None,
+        ManageSubscriptionIntent::UpgradeToPro => {
+            let zed_pro_price_id = app.config.zed_pro_price_id()?;
+            let zed_pro_trial_price_id = app.config.zed_pro_trial_price_id()?;
+            let zed_free_price_id = app.config.zed_free_price_id()?;
+
+            let stripe_subscription =
+                Subscription::retrieve(&stripe_client, &subscription_id, &[]).await?;
+
+            let subscription_item_to_update = stripe_subscription
+                .items
+                .data
+                .iter()
+                .find_map(|item| {
+                    let price = item.price.as_ref()?;
+
+                    if price.id == zed_free_price_id || price.id == zed_pro_trial_price_id {
+                        Some(item.id.clone())
+                    } else {
+                        None
+                    }
+                })
+                .ok_or_else(|| anyhow!("No subscription item to update"))?;
+
+            Some(CreateBillingPortalSessionFlowData {
+                type_: CreateBillingPortalSessionFlowDataType::SubscriptionUpdateConfirm,
+                subscription_update_confirm: Some(
+                    CreateBillingPortalSessionFlowDataSubscriptionUpdateConfirm {
+                        subscription: subscription.stripe_subscription_id,
+                        items: vec![
+                            CreateBillingPortalSessionFlowDataSubscriptionUpdateConfirmItems {
+                                id: subscription_item_to_update.to_string(),
+                                price: Some(zed_pro_price_id.to_string()),
+                                quantity: Some(1),
+                            },
+                        ],
+                        discounts: None,
+                    },
+                ),
+                ..Default::default()
+            })
+        }
        ManageSubscriptionIntent::Cancel => Some(CreateBillingPortalSessionFlowData {
            type_: CreateBillingPortalSessionFlowDataType::SubscriptionCancel,
            after_completion: Some(CreateBillingPortalSessionFlowDataAfterCompletion {
@@ -696,22 +769,25 @@ async fn handle_customer_subscription_event(

    log::info!("handling Stripe {} event: {}", event.type_, event.id);

-    let subscription_kind =
-        if let Some(zed_pro_price_id) = app.config.stripe_zed_pro_price_id.as_deref() {
-            let has_zed_pro_price = subscription.items.data.iter().any(|item| {
-                item.price
-                    .as_ref()
-                    .map_or(false, |price| price.id.as_str() == zed_pro_price_id)
-            });
+    let subscription_kind = maybe!({
+        let zed_pro_price_id = app.config.zed_pro_price_id().ok()?;
+        let zed_pro_trial_price_id = app.config.zed_pro_trial_price_id().ok()?;
+        let zed_free_price_id = app.config.zed_free_price_id().ok()?;

-            if has_zed_pro_price {
+        subscription.items.data.iter().find_map(|item| {
+            let price = item.price.as_ref()?;
+
+            if price.id == zed_pro_price_id {
                Some(SubscriptionKind::ZedPro)
+            } else if price.id == zed_pro_trial_price_id {
+                Some(SubscriptionKind::ZedProTrial)
+            } else if price.id == zed_free_price_id {
+                Some(SubscriptionKind::ZedFree)
            } else {
                None
            }
-        } else {
-            None
-        };
+        })
+    });

    let billing_customer =
        find_or_create_billing_customer(app, stripe_client, subscription.customer)
@@ -874,6 +950,105 @@ async fn get_monthly_spend(
    }))
 }

+#[derive(Debug, Deserialize)]
+struct GetCurrentUsageParams {
+    github_user_id: i32,
+}
+
+#[derive(Debug, Serialize)]
+struct UsageCounts {
+    pub used: i32,
+    pub limit: Option<i32>,
+    pub remaining: Option<i32>,
+}
+
+#[derive(Debug, Serialize)]
+struct GetCurrentUsageResponse {
+    pub model_requests: UsageCounts,
+    pub edit_predictions: UsageCounts,
+}
+
+async fn get_current_usage(
+    Extension(app): Extension<Arc<AppState>>,
+    Query(params): Query<GetCurrentUsageParams>,
+) -> Result<Json<GetCurrentUsageResponse>> {
+    let user = app
+        .db
+        .get_user_by_github_user_id(params.github_user_id)
+        .await?
+        .ok_or_else(|| anyhow!("user not found"))?;
+
+    let Some(llm_db) = app.llm_db.clone() else {
+        return Err(Error::http(
+            StatusCode::NOT_IMPLEMENTED,
+            "LLM database not available".into(),
+        ));
+    };
+
+    let empty_usage = GetCurrentUsageResponse {
+        model_requests: UsageCounts {
+            used: 0,
+            limit: Some(0),
+            remaining: Some(0),
+        },
+        edit_predictions: UsageCounts {
+            used: 0,
+            limit: Some(0),
+            remaining: Some(0),
+        },
+    };
+
+    let Some(subscription) = app.db.get_active_billing_subscription(user.id).await? else {
+        return Ok(Json(empty_usage));
+    };
+
+    let subscription_period = maybe!({
+        let period_start_at = subscription.current_period_start_at()?;
+        let period_end_at = subscription.current_period_end_at()?;
+
+        Some((period_start_at, period_end_at))
+    });
+
+    let Some((period_start_at, period_end_at)) = subscription_period else {
+        return Ok(Json(empty_usage));
+    };
+
+    let usage = llm_db
+        .get_subscription_usage_for_period(user.id, period_start_at, period_end_at)
+        .await?;
+    let Some(usage) = usage else {
+        return Ok(Json(empty_usage));
+    };
+
+    let plan = match usage.plan {
+        SubscriptionKind::ZedPro => zed_llm_client::Plan::ZedPro,
+        SubscriptionKind::ZedProTrial => zed_llm_client::Plan::ZedProTrial,
+        SubscriptionKind::ZedFree => zed_llm_client::Plan::Free,
+    };
+
+    let model_requests_limit = match plan.model_requests_limit() {
+        zed_llm_client::UsageLimit::Limited(limit) => Some(limit),
+        zed_llm_client::UsageLimit::Unlimited => None,
+    };
+    let edit_prediction_limit = match plan.edit_predictions_limit() {
+        zed_llm_client::UsageLimit::Limited(limit) => Some(limit),
+        zed_llm_client::UsageLimit::Unlimited => None,
+    };
+
+    Ok(Json(GetCurrentUsageResponse {
+        model_requests: UsageCounts {
+            used: usage.model_requests,
+            limit: model_requests_limit,
+            remaining: model_requests_limit.map(|limit| (limit - usage.model_requests).max(0)),
+        },
+        edit_predictions: UsageCounts {
+            used: usage.edit_predictions,
+            limit: edit_prediction_limit,
+            remaining: edit_prediction_limit.map(|limit| (limit - usage.edit_predictions).max(0)),
+        },
+    }))
+}
+
 impl From<SubscriptionStatus> for StripeSubscriptionStatus {
    fn from(value: SubscriptionStatus) -> Self {
        match value {
--- a/crates/collab/src/db/queries/billing_subscriptions.rs
+++ b/crates/collab/src/db/queries/billing_subscriptions.rs
@@ -62,11 +62,14 @@ impl Database {
            billing_subscription::Entity::update(billing_subscription::ActiveModel {
                id: ActiveValue::set(id),
                billing_customer_id: params.billing_customer_id.clone(),
+                kind: params.kind.clone(),
                stripe_subscription_id: params.stripe_subscription_id.clone(),
                stripe_subscription_status: params.stripe_subscription_status.clone(),
                stripe_cancel_at: params.stripe_cancel_at.clone(),
                stripe_cancellation_reason: params.stripe_cancellation_reason.clone(),
-                ..Default::default()
+                stripe_current_period_start: params.stripe_current_period_start.clone(),
+                stripe_current_period_end: params.stripe_current_period_end.clone(),
+                created_at: ActiveValue::not_set(),
            })
            .exec(&*tx)
            .await?;
@@ -105,6 +108,28 @@ impl Database {
        .await
    }

+    pub async fn get_active_billing_subscription(
+        &self,
+        user_id: UserId,
+    ) -> Result<Option<billing_subscription::Model>> {
+        self.transaction(|tx| async move {
+            Ok(billing_subscription::Entity::find()
+                .inner_join(billing_customer::Entity)
+                .filter(billing_customer::Column::UserId.eq(user_id))
+                .filter(
+                    Condition::all()
+                        .add(
+                            billing_subscription::Column::StripeSubscriptionStatus
+                                .eq(StripeSubscriptionStatus::Active),
+                        )
+                        .add(billing_subscription::Column::Kind.is_not_null()),
+                )
+                .one(&*tx)
+                .await?)
+        })
+        .await
+    }
+
    /// Returns all of the billing subscriptions for the user with the specified ID.
    ///
    /// Note that this returns the subscriptions regardless of their status.
@@ -142,6 +167,7 @@ impl Database {
                        billing_subscription::Column::StripeSubscriptionStatus
                            .eq(StripeSubscriptionStatus::Active),
                    )
+                    .filter(billing_subscription::Column::Kind.is_null())
                    .order_by_asc(billing_subscription::Column::Id)
                    .stream(&*tx)
                    .await?;
--- a/crates/collab/src/db/tables/billing_subscription.rs
+++ b/crates/collab/src/db/tables/billing_subscription.rs
@@ -19,6 +19,18 @@ pub struct Model {
    pub created_at: DateTime,
 }

+impl Model {
+    pub fn current_period_start_at(&self) -> Option<DateTimeUtc> {
+        let period_start = self.stripe_current_period_start?;
+        chrono::DateTime::from_timestamp(period_start, 0)
+    }
+
+    pub fn current_period_end_at(&self) -> Option<DateTimeUtc> {
+        let period_end = self.stripe_current_period_end?;
+        chrono::DateTime::from_timestamp(period_end, 0)
+    }
+}
+
 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
 pub enum Relation {
    #[sea_orm(
@@ -43,6 +55,10 @@ impl ActiveModelBehavior for ActiveModel {}
 pub enum SubscriptionKind {
    #[sea_orm(string_value = "zed_pro")]
    ZedPro,
+    #[sea_orm(string_value = "zed_pro_trial")]
+    ZedProTrial,
+    #[sea_orm(string_value = "zed_free")]
+    ZedFree,
 }

 /// The status of a Stripe subscription.
--- a/crates/collab/src/lib.rs
+++ b/crates/collab/src/lib.rs
@@ -183,6 +183,8 @@ pub struct Config {
    pub auto_join_channel_id: Option<ChannelId>,
    pub stripe_api_key: Option<String>,
    pub stripe_zed_pro_price_id: Option<String>,
+    pub stripe_zed_pro_trial_price_id: Option<String>,
+    pub stripe_zed_free_price_id: Option<String>,
    pub supermaven_admin_api_key: Option<Arc<str>>,
    pub user_backfiller_github_access_token: Option<Arc<str>>,
 }
@@ -201,6 +203,29 @@ impl Config {
        }
    }

+    pub fn zed_pro_price_id(&self) -> anyhow::Result<stripe::PriceId> {
+        Self::parse_stripe_price_id("Zed Pro", self.stripe_zed_pro_price_id.as_deref())
+    }
+
+    pub fn zed_pro_trial_price_id(&self) -> anyhow::Result<stripe::PriceId> {
+        Self::parse_stripe_price_id(
+            "Zed Pro Trial",
+            self.stripe_zed_pro_trial_price_id.as_deref(),
+        )
+    }
+
+    pub fn zed_free_price_id(&self) -> anyhow::Result<stripe::PriceId> {
+        Self::parse_stripe_price_id("Zed Free", self.stripe_zed_pro_price_id.as_deref())
+    }
+
+    fn parse_stripe_price_id(name: &str, value: Option<&str>) -> anyhow::Result<stripe::PriceId> {
+        use std::str::FromStr as _;
+
+        let price_id = value.ok_or_else(|| anyhow!("{name} price ID not set"))?;
+
+        Ok(stripe::PriceId::from_str(price_id)?)
+    }
+
    #[cfg(test)]
    pub fn test() -> Self {
        Self {
@@ -239,6 +264,8 @@ impl Config {
            seed_path: None,
            stripe_api_key: None,
            stripe_zed_pro_price_id: None,
+            stripe_zed_pro_trial_price_id: None,
+            stripe_zed_free_price_id: None,
            supermaven_admin_api_key: None,
            user_backfiller_github_access_token: None,
            kinesis_region: None,
@@ -324,12 +351,9 @@ impl AppState {
            llm_db,
            livekit_client,
            blob_store_client: build_blob_store_client(&config).await.log_err(),
-            stripe_billing: stripe_client.clone().map(|stripe_client| {
-                Arc::new(StripeBilling::new(
-                    stripe_client,
-                    config.stripe_zed_pro_price_id.clone(),
-                ))
-            }),
+            stripe_billing: stripe_client
+                .clone()
+                .map(|stripe_client| Arc::new(StripeBilling::new(stripe_client))),
            stripe_client,
            rate_limiter: Arc::new(RateLimiter::new(db)),
            executor,
--- a/crates/collab/src/llm/db.rs
+++ b/crates/collab/src/llm/db.rs
@@ -8,9 +8,9 @@ mod tests;

 use collections::HashMap;
 pub use ids::*;
-use rpc::LanguageModelProvider;
 pub use seed::*;
 pub use tables::*;
+use zed_llm_client::LanguageModelProvider;

 #[cfg(test)]
 pub use tests::TestLlmDb;
--- a/crates/collab/src/llm/db/queries.rs
+++ b/crates/collab/src/llm/db/queries.rs
@@ -2,4 +2,5 @@ use super::*;

 pub mod billing_events;
 pub mod providers;
+pub mod subscription_usages;
 pub mod usages;
--- a/crates/collab/src/llm/db/queries/subscription_usages.rs
+++ b/crates/collab/src/llm/db/queries/subscription_usages.rs
@@ -0,0 +1,22 @@
+use crate::db::UserId;
+
+use super::*;
+
+impl LlmDatabase {
+    pub async fn get_subscription_usage_for_period(
+        &self,
+        user_id: UserId,
+        period_start_at: DateTimeUtc,
+        period_end_at: DateTimeUtc,
+    ) -> Result<Option<subscription_usage::Model>> {
+        self.transaction(|tx| async move {
+            Ok(subscription_usage::Entity::find()
+                .filter(subscription_usage::Column::UserId.eq(user_id))
+                .filter(subscription_usage::Column::PeriodStartAt.eq(period_start_at))
+                .filter(subscription_usage::Column::PeriodEndAt.eq(period_end_at))
+                .one(&*tx)
+                .await?)
+        })
+        .await
+    }
+}
--- a/crates/collab/src/llm/db/tables.rs
+++ b/crates/collab/src/llm/db/tables.rs
@@ -2,5 +2,6 @@ pub mod billing_event;
 pub mod model;
 pub mod monthly_usage;
 pub mod provider;
+pub mod subscription_usage;
 pub mod usage;
 pub mod usage_measure;
--- a/crates/collab/src/llm/db/tables/subscription_usage.rs
+++ b/crates/collab/src/llm/db/tables/subscription_usage.rs
@@ -0,0 +1,22 @@
+use crate::db::UserId;
+use crate::db::billing_subscription::SubscriptionKind;
+use sea_orm::entity::prelude::*;
+use time::PrimitiveDateTime;
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
+#[sea_orm(table_name = "subscription_usages")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub user_id: UserId,
+    pub period_start_at: PrimitiveDateTime,
+    pub period_end_at: PrimitiveDateTime,
+    pub plan: SubscriptionKind,
+    pub model_requests: i32,
+    pub edit_predictions: i32,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}
+
+impl ActiveModelBehavior for ActiveModel {}
--- a/crates/collab/src/llm/db/tests/provider_tests.rs
+++ b/crates/collab/src/llm/db/tests/provider_tests.rs
@@ -1,5 +1,5 @@
 use pretty_assertions::assert_eq;
-use rpc::LanguageModelProvider;
+use zed_llm_client::LanguageModelProvider;

 use crate::llm::db::LlmDatabase;
 use crate::test_llm_db;
--- a/crates/collab/src/llm/token.rs
+++ b/crates/collab/src/llm/token.rs
@@ -1,5 +1,5 @@
 use crate::Cents;
-use crate::db::user;
+use crate::db::{billing_subscription, user};
 use crate::llm::{DEFAULT_MAX_MONTHLY_SPEND, FREE_TIER_MONTHLY_SPENDING_LIMIT};
 use crate::{Config, db::billing_preference};
 use anyhow::{Result, anyhow};
@@ -8,7 +8,9 @@ use jsonwebtoken::{DecodingKey, EncodingKey, Header, Validation};
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
 use thiserror::Error;
+use util::maybe;
 use uuid::Uuid;
+use zed_llm_client::Plan;

 #[derive(Clone, Debug, Default, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -24,11 +26,12 @@ pub struct LlmTokenClaims {
    pub is_staff: bool,
    pub has_llm_closed_beta_feature_flag: bool,
    pub bypass_account_age_check: bool,
-    pub has_predict_edits_feature_flag: bool,
    pub has_llm_subscription: bool,
    pub max_monthly_spend_in_cents: u32,
    pub custom_llm_monthly_allowance_in_cents: Option<u32>,
-    pub plan: rpc::proto::Plan,
+    pub plan: Plan,
+    #[serde(default)]
+    pub subscription_period: Option<(NaiveDateTime, NaiveDateTime)>,
 }

 const LLM_TOKEN_LIFETIME: Duration = Duration::from_secs(60 * 60);
@@ -39,8 +42,9 @@ impl LlmTokenClaims {
        is_staff: bool,
        billing_preferences: Option<billing_preference::Model>,
        feature_flags: &Vec<String>,
-        has_llm_subscription: bool,
+        has_legacy_llm_subscription: bool,
        plan: rpc::proto::Plan,
+        subscription: Option<billing_subscription::Model>,
        system_id: Option<String>,
        config: &Config,
    ) -> Result<String> {
@@ -66,10 +70,7 @@ impl LlmTokenClaims {
            bypass_account_age_check: feature_flags
                .iter()
                .any(|flag| flag == "bypass-account-age-check"),
-            has_predict_edits_feature_flag: feature_flags
-                .iter()
-                .any(|flag| flag == "predict-edits"),
-            has_llm_subscription,
+            has_llm_subscription: has_legacy_llm_subscription,
            max_monthly_spend_in_cents: billing_preferences
                .map_or(DEFAULT_MAX_MONTHLY_SPEND.0, |preferences| {
                    preferences.max_monthly_llm_usage_spending_in_cents as u32
@@ -77,7 +78,18 @@ impl LlmTokenClaims {
            custom_llm_monthly_allowance_in_cents: user
                .custom_llm_monthly_allowance_in_cents
                .map(|allowance| allowance as u32),
-            plan,
+            plan: match plan {
+                rpc::proto::Plan::Free => Plan::Free,
+                rpc::proto::Plan::ZedPro => Plan::ZedPro,
+                rpc::proto::Plan::ZedProTrial => Plan::ZedProTrial,
+            },
+            subscription_period: maybe!({
+                let subscription = subscription?;
+                let period_start_at = subscription.current_period_start_at()?;
+                let period_end_at = subscription.current_period_end_at()?;
+
+                Some((period_start_at.naive_utc(), period_end_at.naive_utc()))
+            }),
        };

        Ok(jsonwebtoken::encode(
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -3707,7 +3707,9 @@ async fn count_language_model_tokens(

    let rate_limit: Box<dyn RateLimit> = match session.current_plan(&session.db().await).await? {
        proto::Plan::ZedPro => Box::new(ZedProCountLanguageModelTokensRateLimit),
-        proto::Plan::Free => Box::new(FreeCountLanguageModelTokensRateLimit),
+        proto::Plan::Free | proto::Plan::ZedProTrial => {
+            Box::new(FreeCountLanguageModelTokensRateLimit)
+        }
    };

    session
@@ -3827,7 +3829,7 @@ async fn compute_embeddings(

    let rate_limit: Box<dyn RateLimit> = match session.current_plan(&session.db().await).await? {
        proto::Plan::ZedPro => Box::new(ZedProComputeEmbeddingsRateLimit),
-        proto::Plan::Free => Box::new(FreeComputeEmbeddingsRateLimit),
+        proto::Plan::Free | proto::Plan::ZedProTrial => Box::new(FreeComputeEmbeddingsRateLimit),
    };

    session
@@ -4135,7 +4137,8 @@ async fn get_llm_api_token(
        Err(anyhow!("terms of service not accepted"))?
    }

-    let has_llm_subscription = session.has_llm_subscription(&db).await?;
+    let has_legacy_llm_subscription = session.has_llm_subscription(&db).await?;
+    let billing_subscription = db.get_active_billing_subscription(user.id).await?;
    let billing_preferences = db.get_billing_preferences(user.id).await?;

    let token = LlmTokenClaims::create(
@@ -4143,8 +4146,9 @@ async fn get_llm_api_token(
        session.is_staff(),
        billing_preferences,
        &flags,
-        has_llm_subscription,
+        has_legacy_llm_subscription,
        session.current_plan(&db).await?,
+        billing_subscription,
        session.system_id.clone(),
        &session.app_state.config,
    )?;
--- a/crates/collab/src/stripe_billing.rs
+++ b/crates/collab/src/stripe_billing.rs
@@ -1,16 +1,16 @@
 use std::sync::Arc;

 use crate::{Cents, Result, llm};
-use anyhow::{Context as _, anyhow};
+use anyhow::Context as _;
 use chrono::{Datelike, Utc};
 use collections::HashMap;
 use serde::{Deserialize, Serialize};
+use stripe::PriceId;
 use tokio::sync::RwLock;

 pub struct StripeBilling {
    state: RwLock<StripeBillingState>,
    client: Arc<stripe::Client>,
-    zed_pro_price_id: Option<String>,
 }

 #[derive(Default)]
@@ -32,11 +32,10 @@ struct StripeBillingPrice {
 }

 impl StripeBilling {
-    pub fn new(client: Arc<stripe::Client>, zed_pro_price_id: Option<String>) -> Self {
+    pub fn new(client: Arc<stripe::Client>) -> Self {
        Self {
            client,
            state: RwLock::default(),
-            zed_pro_price_id,
        }
    }

@@ -385,23 +384,19 @@ impl StripeBilling {
        Ok(session.url.context("no checkout session URL")?)
    }

-    pub async fn checkout_with_zed_pro(
+    pub async fn checkout_with_price(
        &self,
+        price_id: PriceId,
        customer_id: stripe::CustomerId,
        github_login: &str,
        success_url: &str,
    ) -> Result<String> {
-        let zed_pro_price_id = self
-            .zed_pro_price_id
-            .as_ref()
-            .ok_or_else(|| anyhow!("Zed Pro price ID not set"))?;
-
        let mut params = stripe::CreateCheckoutSession::new();
        params.mode = Some(stripe::CheckoutSessionMode::Subscription);
        params.customer = Some(customer_id);
        params.client_reference_id = Some(github_login);
        params.line_items = Some(vec![stripe::CreateCheckoutSessionLineItems {
-            price: Some(zed_pro_price_id.clone()),
+            price: Some(price_id.to_string()),
            quantity: Some(1),
            ..Default::default()
        }]);
--- a/crates/collab/src/tests/test_server.rs
+++ b/crates/collab/src/tests/test_server.rs
@@ -558,6 +558,8 @@ impl TestServer {
                seed_path: None,
                stripe_api_key: None,
                stripe_zed_pro_price_id: None,
+                stripe_zed_pro_trial_price_id: None,
+                stripe_zed_free_price_id: None,
                supermaven_admin_api_key: None,
                user_backfiller_github_access_token: None,
                kinesis_region: None,
--- a/crates/dap/src/adapters.rs
+++ b/crates/dap/src/adapters.rs
@@ -1,5 +1,5 @@
 use ::fs::Fs;
-use anyhow::{Context as _, Ok, Result, anyhow};
+use anyhow::{Context as _, Result, anyhow};
 use async_compression::futures::bufread::GzipDecoder;
 use async_tar::Archive;
 use async_trait::async_trait;
@@ -256,7 +256,21 @@ pub trait DebugAdapter: 'static + Send + Sync {
                self.name()
            );
            delegate.update_status(self.name(), DapStatus::Downloading);
-            self.install_binary(version, delegate).await?;
+            match self.install_binary(version, delegate).await {
+                Ok(_) => {
+                    delegate.update_status(self.name(), DapStatus::None);
+                }
+                Err(error) => {
+                    delegate.update_status(
+                        self.name(),
+                        DapStatus::Failed {
+                            error: error.to_string(),
+                        },
+                    );
+
+                    return Err(error);
+                }
+            }

            delegate
                .updated_adapters()
--- a/crates/dap/src/dap.rs
+++ b/crates/dap/src/dap.rs
@@ -7,7 +7,7 @@ pub mod transport;

 pub use dap_types::*;
 pub use registry::DapRegistry;
-pub use task::{DebugAdapterConfig, DebugRequestType};
+pub use task::DebugRequestType;

 pub type ScopeId = u64;
 pub type VariableReference = u64;
--- a/crates/debugger_ui/src/debugger_panel.rs
+++ b/crates/debugger_ui/src/debugger_panel.rs
@@ -12,8 +12,9 @@ use dap::{
 };
 use futures::{SinkExt as _, channel::mpsc};
 use gpui::{
-    Action, App, AsyncWindowContext, Context, Entity, EntityId, EventEmitter, FocusHandle,
-    Focusable, Subscription, Task, WeakEntity, actions,
+    Action, App, AsyncWindowContext, Context, DismissEvent, Entity, EntityId, EventEmitter,
+    FocusHandle, Focusable, MouseButton, MouseDownEvent, Point, Subscription, Task, WeakEntity,
+    actions, anchored, deferred,
 };

 use project::{
@@ -32,6 +33,7 @@ use std::sync::Arc;
 use task::DebugTaskDefinition;
 use terminal_view::terminal_panel::TerminalPanel;
 use ui::{ContextMenu, Divider, DropdownMenu, Tooltip, prelude::*};
+use util::debug_panic;
 use workspace::{
    Workspace,
    dock::{DockPosition, Panel, PanelEvent},
@@ -64,6 +66,7 @@ pub struct DebugPanel {
    project: WeakEntity<Project>,
    workspace: WeakEntity<Workspace>,
    focus_handle: FocusHandle,
+    context_menu: Option<(Entity<ContextMenu>, Point<Pixels>, Subscription)>,
    _subscriptions: Vec<Subscription>,
 }

@@ -126,6 +129,7 @@ impl DebugPanel {
                focus_handle: cx.focus_handle(),
                project: project.downgrade(),
                workspace: workspace.weak_handle(),
+                context_menu: None,
            };

            debug_panel
@@ -313,8 +317,20 @@ impl DebugPanel {
                            .any(|item| item.read(cx).session_id(cx) == session_id)
                        {
                            // We already have an item for this session.
+                            debug_panic!("We should never reuse session ids");
                            return;
                        }
+
+                        this.sessions.retain(|session| {
+                            session
+                                .read(cx)
+                                .mode()
+                                .as_running()
+                                .map_or(false, |running_state| {
+                                    !running_state.read(cx).session().read(cx).is_terminated()
+                                })
+                        });
+
                        let session_item = DebugSession::running(
                            project,
                            this.workspace.clone(),
@@ -438,7 +454,13 @@ impl DebugPanel {
        else {
            return;
        };
-
+        session.update(cx, |this, cx| {
+            if let Some(running) = this.mode().as_running() {
+                running.update(cx, |this, cx| {
+                    this.serialize_layout(window, cx);
+                });
+            }
+        });
        let session_id = session.update(cx, |this, cx| this.session_id(cx));
        let should_prompt = self
            .project
@@ -567,6 +589,57 @@ impl DebugPanel {
        )
    }

+    fn deploy_context_menu(
+        &mut self,
+        position: Point<Pixels>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if let Some(running_state) = self
+            .active_session
+            .as_ref()
+            .and_then(|session| session.read(cx).mode().as_running().cloned())
+        {
+            let pane_items_status = running_state.read(cx).pane_items_status(cx);
+            let this = cx.weak_entity();
+
+            let context_menu = ContextMenu::build(window, cx, |mut menu, _window, _cx| {
+                for (item_kind, is_visible) in pane_items_status.into_iter() {
+                    menu = menu.toggleable_entry(item_kind, is_visible, IconPosition::End, None, {
+                        let this = this.clone();
+                        move |window, cx| {
+                            this.update(cx, |this, cx| {
+                                if let Some(running_state) =
+                                    this.active_session.as_ref().and_then(|session| {
+                                        session.read(cx).mode().as_running().cloned()
+                                    })
+                                {
+                                    running_state.update(cx, |state, cx| {
+                                        if is_visible {
+                                            state.remove_pane_item(item_kind, window, cx);
+                                        } else {
+                                            state.add_pane_item(item_kind, position, window, cx);
+                                        }
+                                    })
+                                }
+                            })
+                            .ok();
+                        }
+                    });
+                }
+
+                menu
+            });
+
+            window.focus(&context_menu.focus_handle(cx));
+            let subscription = cx.subscribe(&context_menu, |this, _, _: &DismissEvent, cx| {
+                this.context_menu.take();
+                cx.notify();
+            });
+            self.context_menu = Some((context_menu, position, subscription));
+        }
+    }
+
    fn top_controls_strip(&self, window: &mut Window, cx: &mut Context<Self>) -> Option<Div> {
        let active_session = self.active_session.clone();

@@ -709,9 +782,6 @@ impl DebugPanel {
                                            this.restart_session(cx);
                                        },
                                    ))
-                                    .disabled(
-                                        !capabilities.supports_restart_request.unwrap_or_default(),
-                                    )
                                    .tooltip(move |window, cx| {
                                        Tooltip::text("Restart")(window, cx)
                                    }),
@@ -891,11 +961,49 @@ impl Render for DebugPanel {
        let has_sessions = self.sessions.len() > 0;
        debug_assert_eq!(has_sessions, self.active_session.is_some());

+        if self
+            .active_session
+            .as_ref()
+            .and_then(|session| session.read(cx).mode().as_running().cloned())
+            .map(|state| state.read(cx).has_open_context_menu(cx))
+            .unwrap_or(false)
+        {
+            self.context_menu.take();
+        }
+
        v_flex()
            .size_full()
            .key_context("DebugPanel")
            .child(h_flex().children(self.top_controls_strip(window, cx)))
            .track_focus(&self.focus_handle(cx))
+            .when(self.active_session.is_some(), |this| {
+                this.on_mouse_down(
+                    MouseButton::Right,
+                    cx.listener(|this, event: &MouseDownEvent, window, cx| {
+                        if this
+                            .active_session
+                            .as_ref()
+                            .and_then(|session| {
+                                session.read(cx).mode().as_running().map(|state| {
+                                    state.read(cx).has_pane_at_position(event.position)
+                                })
+                            })
+                            .unwrap_or(false)
+                        {
+                            this.deploy_context_menu(event.position, window, cx);
+                        }
+                    }),
+                )
+                .children(self.context_menu.as_ref().map(|(menu, position, _)| {
+                    deferred(
+                        anchored()
+                            .position(*position)
+                            .anchor(gpui::Corner::TopLeft)
+                            .child(menu.clone()),
+                    )
+                    .with_priority(1)
+                }))
+            })
            .map(|this| {
                if has_sessions {
                    this.children(self.active_session.clone())
--- a/crates/debugger_ui/src/persistence.rs
+++ b/crates/debugger_ui/src/persistence.rs
@@ -1,4 +1,5 @@
 use collections::HashMap;
+use dap::Capabilities;
 use db::kvp::KEY_VALUE_STORE;
 use gpui::{Axis, Context, Entity, EntityId, Focusable, Subscription, WeakEntity, Window};
 use project::Project;
@@ -9,19 +10,43 @@ use workspace::{Member, Pane, PaneAxis, Workspace};

 use crate::session::running::{
    self, RunningState, SubView, breakpoint_list::BreakpointList, console::Console,
-    module_list::ModuleList, stack_frame_list::StackFrameList, variable_list::VariableList,
+    loaded_source_list::LoadedSourceList, module_list::ModuleList,
+    stack_frame_list::StackFrameList, variable_list::VariableList,
 };

-#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[derive(Clone, Hash, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)]
 pub(crate) enum DebuggerPaneItem {
    Console,
    Variables,
    BreakpointList,
    Frames,
    Modules,
+    LoadedSources,
 }

 impl DebuggerPaneItem {
+    pub(crate) fn all() -> &'static [DebuggerPaneItem] {
+        static VARIANTS: &[DebuggerPaneItem] = &[
+            DebuggerPaneItem::Console,
+            DebuggerPaneItem::Variables,
+            DebuggerPaneItem::BreakpointList,
+            DebuggerPaneItem::Frames,
+            DebuggerPaneItem::Modules,
+            DebuggerPaneItem::LoadedSources,
+        ];
+        VARIANTS
+    }
+
+    pub(crate) fn is_supported(&self, capabilities: &Capabilities) -> bool {
+        match self {
+            DebuggerPaneItem::Modules => capabilities.supports_modules_request.unwrap_or_default(),
+            DebuggerPaneItem::LoadedSources => capabilities
+                .supports_loaded_sources_request
+                .unwrap_or_default(),
+            _ => true,
+        }
+    }
+
    pub(crate) fn to_shared_string(self) -> SharedString {
        match self {
            DebuggerPaneItem::Console => SharedString::new_static("Console"),
@@ -29,10 +54,17 @@ impl DebuggerPaneItem {
            DebuggerPaneItem::BreakpointList => SharedString::new_static("Breakpoints"),
            DebuggerPaneItem::Frames => SharedString::new_static("Frames"),
            DebuggerPaneItem::Modules => SharedString::new_static("Modules"),
+            DebuggerPaneItem::LoadedSources => SharedString::new_static("Sources"),
        }
    }
 }

+impl From<DebuggerPaneItem> for SharedString {
+    fn from(item: DebuggerPaneItem) -> Self {
+        item.to_shared_string()
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 pub(crate) struct SerializedAxis(pub Axis);

@@ -136,6 +168,7 @@ pub(crate) fn deserialize_pane_layout(
    module_list: &Entity<ModuleList>,
    console: &Entity<Console>,
    breakpoint_list: &Entity<BreakpointList>,
+    loaded_sources: &Entity<LoadedSourceList>,
    subscriptions: &mut HashMap<EntityId, Subscription>,
    window: &mut Window,
    cx: &mut Context<RunningState>,
@@ -157,6 +190,7 @@ pub(crate) fn deserialize_pane_layout(
                    module_list,
                    console,
                    breakpoint_list,
+                    loaded_sources,
                    subscriptions,
                    window,
                    cx,
@@ -191,7 +225,7 @@ pub(crate) fn deserialize_pane_layout(
                .iter()
                .map(|child| match child {
                    DebuggerPaneItem::Frames => Box::new(SubView::new(
-                        pane.focus_handle(cx),
+                        stack_frame_list.focus_handle(cx),
                        stack_frame_list.clone().into(),
                        DebuggerPaneItem::Frames,
                        None,
@@ -212,13 +246,19 @@ pub(crate) fn deserialize_pane_layout(
                        cx,
                    )),
                    DebuggerPaneItem::Modules => Box::new(SubView::new(
-                        pane.focus_handle(cx),
+                        module_list.focus_handle(cx),
                        module_list.clone().into(),
                        DebuggerPaneItem::Modules,
                        None,
                        cx,
                    )),
-
+                    DebuggerPaneItem::LoadedSources => Box::new(SubView::new(
+                        loaded_sources.focus_handle(cx),
+                        loaded_sources.clone().into(),
+                        DebuggerPaneItem::LoadedSources,
+                        None,
+                        cx,
+                    )),
                    DebuggerPaneItem::Console => Box::new(SubView::new(
                        pane.focus_handle(cx),
                        console.clone().into(),
--- a/crates/debugger_ui/src/session/running.rs
+++ b/crates/debugger_ui/src/session/running.rs
@@ -11,12 +11,12 @@ use crate::persistence::{self, DebuggerPaneItem, SerializedPaneLayout};

 use super::DebugPanelItemEvent;
 use breakpoint_list::BreakpointList;
-use collections::HashMap;
+use collections::{HashMap, IndexMap};
 use console::Console;
 use dap::{Capabilities, Thread, client::SessionId, debugger_settings::DebuggerSettings};
 use gpui::{
    Action as _, AnyView, AppContext, Entity, EntityId, EventEmitter, FocusHandle, Focusable,
-    NoAction, Subscription, Task, WeakEntity,
+    NoAction, Pixels, Point, Subscription, Task, WeakEntity,
 };
 use loaded_source_list::LoadedSourceList;
 use module_list::ModuleList;
@@ -49,8 +49,10 @@ pub struct RunningState {
    variable_list: Entity<variable_list::VariableList>,
    _subscriptions: Vec<Subscription>,
    stack_frame_list: Entity<stack_frame_list::StackFrameList>,
-    _module_list: Entity<module_list::ModuleList>,
+    loaded_sources_list: Entity<LoadedSourceList>,
+    module_list: Entity<module_list::ModuleList>,
    _console: Entity<Console>,
+    breakpoint_list: Entity<BreakpointList>,
    panes: PaneGroup,
    pane_close_subscriptions: HashMap<EntityId, Subscription>,
    _schedule_serialize: Option<Task<()>>,
@@ -383,7 +385,6 @@ impl RunningState {

        let module_list = cx.new(|cx| ModuleList::new(session.clone(), workspace.clone(), cx));

-        #[expect(unused)]
        let loaded_source_list = cx.new(|cx| LoadedSourceList::new(session.clone(), cx));

        let console = cx.new(|cx| {
@@ -396,7 +397,7 @@ impl RunningState {
            )
        });

-        let breakpoints = BreakpointList::new(session.clone(), workspace.clone(), &project, cx);
+        let breakpoint_list = BreakpointList::new(session.clone(), workspace.clone(), &project, cx);

        let _subscriptions = vec![
            cx.observe(&module_list, |_, _, cx| cx.notify()),
@@ -421,6 +422,9 @@ impl RunningState {
                }
                cx.notify()
            }),
+            cx.on_focus_out(&focus_handle, window, |this, _, window, cx| {
+                this.serialize_layout(window, cx);
+            }),
        ];

        let mut pane_close_subscriptions = HashMap::default();
@@ -433,7 +437,8 @@ impl RunningState {
                &variable_list,
                &module_list,
                &console,
-                &breakpoints,
+                &breakpoint_list,
+                &loaded_source_list,
                &mut pane_close_subscriptions,
                window,
                cx,
@@ -449,7 +454,7 @@ impl RunningState {
                &variable_list,
                &module_list,
                &console,
-                breakpoints,
+                &breakpoint_list,
                &mut pane_close_subscriptions,
                window,
                cx,
@@ -469,14 +474,140 @@ impl RunningState {
            stack_frame_list,
            session_id,
            panes,
-            _module_list: module_list,
+            module_list,
            _console: console,
+            breakpoint_list,
+            loaded_sources_list: loaded_source_list,
            pane_close_subscriptions,
            _schedule_serialize: None,
        }
    }

-    fn serialize_layout(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+    pub(crate) fn remove_pane_item(
+        &mut self,
+        item_kind: DebuggerPaneItem,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        debug_assert!(
+            item_kind.is_supported(self.session.read(cx).capabilities()),
+            "We should only allow removing supported item kinds"
+        );
+
+        if let Some((pane, item_id)) = self.panes.panes().iter().find_map(|pane| {
+            Some(pane).zip(
+                pane.read(cx)
+                    .items()
+                    .find(|item| {
+                        item.act_as::<SubView>(cx)
+                            .is_some_and(|view| view.read(cx).kind == item_kind)
+                    })
+                    .map(|item| item.item_id()),
+            )
+        }) {
+            pane.update(cx, |pane, cx| {
+                pane.remove_item(item_id, false, true, window, cx)
+            })
+        }
+    }
+
+    pub(crate) fn has_pane_at_position(&self, position: Point<Pixels>) -> bool {
+        self.panes.pane_at_pixel_position(position).is_some()
+    }
+
+    pub(crate) fn add_pane_item(
+        &mut self,
+        item_kind: DebuggerPaneItem,
+        position: Point<Pixels>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        debug_assert!(
+            item_kind.is_supported(self.session.read(cx).capabilities()),
+            "We should only allow adding supported item kinds"
+        );
+
+        if let Some(pane) = self.panes.pane_at_pixel_position(position) {
+            let sub_view = match item_kind {
+                DebuggerPaneItem::Console => {
+                    let weak_console = self._console.clone().downgrade();
+
+                    Box::new(SubView::new(
+                        pane.focus_handle(cx),
+                        self._console.clone().into(),
+                        item_kind,
+                        Some(Box::new(move |cx| {
+                            weak_console
+                                .read_with(cx, |console, cx| console.show_indicator(cx))
+                                .unwrap_or_default()
+                        })),
+                        cx,
+                    ))
+                }
+                DebuggerPaneItem::Variables => Box::new(SubView::new(
+                    self.variable_list.focus_handle(cx),
+                    self.variable_list.clone().into(),
+                    item_kind,
+                    None,
+                    cx,
+                )),
+                DebuggerPaneItem::BreakpointList => Box::new(SubView::new(
+                    self.breakpoint_list.focus_handle(cx),
+                    self.breakpoint_list.clone().into(),
+                    item_kind,
+                    None,
+                    cx,
+                )),
+                DebuggerPaneItem::Frames => Box::new(SubView::new(
+                    self.stack_frame_list.focus_handle(cx),
+                    self.stack_frame_list.clone().into(),
+                    item_kind,
+                    None,
+                    cx,
+                )),
+                DebuggerPaneItem::Modules => Box::new(SubView::new(
+                    self.module_list.focus_handle(cx),
+                    self.module_list.clone().into(),
+                    item_kind,
+                    None,
+                    cx,
+                )),
+                DebuggerPaneItem::LoadedSources => Box::new(SubView::new(
+                    self.loaded_sources_list.focus_handle(cx),
+                    self.loaded_sources_list.clone().into(),
+                    item_kind,
+                    None,
+                    cx,
+                )),
+            };
+
+            pane.update(cx, |pane, cx| {
+                pane.add_item(sub_view, false, false, None, window, cx);
+            })
+        }
+    }
+
+    pub(crate) fn pane_items_status(&self, cx: &App) -> IndexMap<DebuggerPaneItem, bool> {
+        let caps = self.session.read(cx).capabilities();
+        let mut pane_item_status = IndexMap::from_iter(
+            DebuggerPaneItem::all()
+                .iter()
+                .filter(|kind| kind.is_supported(&caps))
+                .map(|kind| (*kind, false)),
+        );
+        self.panes.panes().iter().for_each(|pane| {
+            pane.read(cx)
+                .items()
+                .filter_map(|item| item.act_as::<SubView>(cx))
+                .for_each(|view| {
+                    pane_item_status.insert(view.read(cx).kind, true);
+                });
+        });
+
+        pane_item_status
+    }
+
+    pub(crate) fn serialize_layout(&mut self, window: &mut Window, cx: &mut Context<Self>) {
        if self._schedule_serialize.is_none() {
            self._schedule_serialize = Some(cx.spawn_in(window, async move |this, cx| {
                cx.background_executor()
@@ -530,6 +661,10 @@ impl RunningState {
        }
    }

+    pub(crate) fn has_open_context_menu(&self, cx: &App) -> bool {
+        self.variable_list.read(cx).has_open_context_menu()
+    }
+
    pub fn session(&self) -> &Entity<Session> {
        &self.session
    }
@@ -554,7 +689,7 @@ impl RunningState {

    #[cfg(test)]
    pub(crate) fn module_list(&self) -> &Entity<ModuleList> {
-        &self._module_list
+        &self.module_list
    }

    #[cfg(test)]
@@ -790,7 +925,7 @@ impl RunningState {
        variable_list: &Entity<VariableList>,
        module_list: &Entity<ModuleList>,
        console: &Entity<Console>,
-        breakpoints: Entity<BreakpointList>,
+        breakpoints: &Entity<BreakpointList>,
        subscriptions: &mut HashMap<EntityId, Subscription>,
        window: &mut Window,
        cx: &mut Context<'_, RunningState>,
@@ -814,7 +949,7 @@ impl RunningState {
            this.add_item(
                Box::new(SubView::new(
                    breakpoints.focus_handle(cx),
-                    breakpoints.into(),
+                    breakpoints.clone().into(),
                    DebuggerPaneItem::BreakpointList,
                    None,
                    cx,
--- a/crates/debugger_ui/src/session/running/loaded_source_list.rs
+++ b/crates/debugger_ui/src/session/running/loaded_source_list.rs
@@ -3,7 +3,7 @@ use project::debugger::session::{Session, SessionEvent};
 use ui::prelude::*;
 use util::maybe;

-pub struct LoadedSourceList {
+pub(crate) struct LoadedSourceList {
    list: ListState,
    invalidate: bool,
    focus_handle: FocusHandle,
--- a/crates/debugger_ui/src/session/running/variable_list.rs
+++ b/crates/debugger_ui/src/session/running/variable_list.rs
@@ -194,6 +194,10 @@ impl VariableList {
        }
    }

+    pub(super) fn has_open_context_menu(&self) -> bool {
+        self.open_context_menu.is_some()
+    }
+
    fn build_entries(&mut self, cx: &mut Context<Self>) {
        let Some(stack_frame_id) = self.selected_stack_frame_id else {
            return;
--- a/crates/diagnostics/src/diagnostic_renderer.rs
+++ b/crates/diagnostics/src/diagnostic_renderer.rs
@@ -15,7 +15,7 @@ use text::{AnchorRangeExt, Point};
 use theme::ThemeSettings;
 use ui::{
    ActiveTheme, AnyElement, App, Context, IntoElement, ParentElement, SharedString, Styled,
-    Window, div, px,
+    Window, div,
 };
 use util::maybe;

@@ -166,7 +166,8 @@ impl DiagnosticBlock {
    pub fn render_block(&self, editor: WeakEntity<Editor>, bcx: &BlockContext) -> AnyElement {
        let cx = &bcx.app;
        let status_colors = bcx.app.theme().status();
-        let max_width = px(600.);
+
+        let max_width = bcx.em_width * 100.;

        let (background_color, border_color) = match self.severity {
            DiagnosticSeverity::ERROR => (status_colors.error_background, status_colors.error),
--- a/crates/diagnostics/src/diagnostics.rs
+++ b/crates/diagnostics/src/diagnostics.rs
@@ -46,7 +46,8 @@ use workspace::{

 actions!(diagnostics, [Deploy, ToggleWarnings]);

-struct IncludeWarnings(bool);
+#[derive(Default)]
+pub(crate) struct IncludeWarnings(bool);
 impl Global for IncludeWarnings {}

 pub fn init(cx: &mut App) {
@@ -209,6 +210,7 @@ impl ProjectDiagnosticsEditor {
        .detach();
        cx.observe_global_in::<IncludeWarnings>(window, |this, window, cx| {
            this.include_warnings = cx.global::<IncludeWarnings>().0;
+            this.diagnostics.clear();
            this.update_all_excerpts(window, cx);
        })
        .detach();
@@ -300,11 +302,8 @@ impl ProjectDiagnosticsEditor {
        }
    }

-    fn toggle_warnings(&mut self, _: &ToggleWarnings, window: &mut Window, cx: &mut Context<Self>) {
-        self.include_warnings = !self.include_warnings;
-        cx.set_global(IncludeWarnings(self.include_warnings));
-        self.update_all_excerpts(window, cx);
-        cx.notify();
+    fn toggle_warnings(&mut self, _: &ToggleWarnings, _: &mut Window, cx: &mut Context<Self>) {
+        cx.set_global(IncludeWarnings(!self.include_warnings));
    }

    fn focus_in(&mut self, window: &mut Window, cx: &mut Context<Self>) {
@@ -381,7 +380,6 @@ impl ProjectDiagnosticsEditor {
                    Point::zero()..buffer_snapshot.max_point(),
                    false,
                )
-                .filter(|d| !(d.diagnostic.is_primary && d.diagnostic.is_unnecessary))
                .collect::<Vec<_>>();
            let unchanged = this.update(cx, |this, _| {
                if this.diagnostics.get(&buffer_id).is_some_and(|existing| {
@@ -482,7 +480,10 @@ impl ProjectDiagnosticsEditor {
                            editor.change_selections(Some(Autoscroll::fit()), window, cx, |s| {
                                s.select_anchor_ranges([range_to_select]);
                            })
-                        })
+                        });
+                        if this.focus_handle.is_focused(window) {
+                            this.editor.read(cx).focus_handle(cx).focus(window);
+                        }
                    }
                }

--- a/crates/diagnostics/src/diagnostics_tests.rs
+++ b/crates/diagnostics/src/diagnostics_tests.rs
@@ -1,9 +1,9 @@
 use super::*;
 use collections::{HashMap, HashSet};
 use editor::{
-    DisplayPoint,
+    DisplayPoint, InlayId,
    actions::{GoToDiagnostic, GoToPreviousDiagnostic, MoveToBeginning},
-    display_map::DisplayRow,
+    display_map::{DisplayRow, Inlay},
    test::{editor_content_with_blocks, editor_test_context::EditorTestContext},
 };
 use gpui::{TestAppContext, VisualTestContext};
@@ -620,7 +620,7 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
 }

 #[gpui::test(iterations = 20)]
-async fn test_random_diagnostics(cx: &mut TestAppContext, mut rng: StdRng) {
+async fn test_random_diagnostics_blocks(cx: &mut TestAppContext, mut rng: StdRng) {
    init_test(cx);

    let operations = env::var("OPERATIONS")
@@ -779,6 +779,162 @@ async fn test_random_diagnostics(cx: &mut TestAppContext, mut rng: StdRng) {
    }
 }

+// similar to above, but with inlays. Used to find panics when mixing diagnostics and inlays.
+#[gpui::test]
+async fn test_random_diagnostics_with_inlays(cx: &mut TestAppContext, mut rng: StdRng) {
+    init_test(cx);
+
+    let operations = env::var("OPERATIONS")
+        .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
+        .unwrap_or(10);
+
+    let fs = FakeFs::new(cx.executor());
+    fs.insert_tree(path!("/test"), json!({})).await;
+
+    let project = Project::test(fs.clone(), [path!("/test").as_ref()], cx).await;
+    let lsp_store = project.read_with(cx, |project, _| project.lsp_store());
+    let window = cx.add_window(|window, cx| Workspace::test_new(project.clone(), window, cx));
+    let cx = &mut VisualTestContext::from_window(*window, cx);
+    let workspace = window.root(cx).unwrap();
+
+    let mutated_diagnostics = window.build_entity(cx, |window, cx| {
+        ProjectDiagnosticsEditor::new(true, project.clone(), workspace.downgrade(), window, cx)
+    });
+
+    workspace.update_in(cx, |workspace, window, cx| {
+        workspace.add_item_to_center(Box::new(mutated_diagnostics.clone()), window, cx);
+    });
+    mutated_diagnostics.update_in(cx, |diagnostics, window, _cx| {
+        assert!(diagnostics.focus_handle.is_focused(window));
+    });
+
+    let mut next_id = 0;
+    let mut next_filename = 0;
+    let mut language_server_ids = vec![LanguageServerId(0)];
+    let mut updated_language_servers = HashSet::default();
+    let mut current_diagnostics: HashMap<(PathBuf, LanguageServerId), Vec<lsp::Diagnostic>> =
+        Default::default();
+    let mut next_inlay_id = 0;
+
+    for _ in 0..operations {
+        match rng.gen_range(0..100) {
+            // language server completes its diagnostic check
+            0..=20 if !updated_language_servers.is_empty() => {
+                let server_id = *updated_language_servers.iter().choose(&mut rng).unwrap();
+                log::info!("finishing diagnostic check for language server {server_id}");
+                lsp_store.update(cx, |lsp_store, cx| {
+                    lsp_store.disk_based_diagnostics_finished(server_id, cx)
+                });
+
+                if rng.gen_bool(0.5) {
+                    cx.run_until_parked();
+                }
+            }
+
+            21..=50 => mutated_diagnostics.update_in(cx, |diagnostics, window, cx| {
+                diagnostics.editor.update(cx, |editor, cx| {
+                    let snapshot = editor.snapshot(window, cx);
+                    if snapshot.buffer_snapshot.len() > 0 {
+                        let position = rng.gen_range(0..snapshot.buffer_snapshot.len());
+                        let position = snapshot.buffer_snapshot.clip_offset(position, Bias::Left);
+                        log::info!(
+                            "adding inlay at {position}/{}: {:?}",
+                            snapshot.buffer_snapshot.len(),
+                            snapshot.buffer_snapshot.text(),
+                        );
+
+                        editor.splice_inlays(
+                            &[],
+                            vec![Inlay {
+                                id: InlayId::InlineCompletion(post_inc(&mut next_inlay_id)),
+                                position: snapshot.buffer_snapshot.anchor_before(position),
+                                text: Rope::from(format!("Test inlay {next_inlay_id}")),
+                            }],
+                            cx,
+                        );
+                    }
+                });
+            }),
+
+            // language server updates diagnostics
+            _ => {
+                let (path, server_id, diagnostics) =
+                    match current_diagnostics.iter_mut().choose(&mut rng) {
+                        // update existing set of diagnostics
+                        Some(((path, server_id), diagnostics)) if rng.gen_bool(0.5) => {
+                            (path.clone(), *server_id, diagnostics)
+                        }
+
+                        // insert a set of diagnostics for a new path
+                        _ => {
+                            let path: PathBuf =
+                                format!(path!("/test/{}.rs"), post_inc(&mut next_filename)).into();
+                            let len = rng.gen_range(128..256);
+                            let content =
+                                RandomCharIter::new(&mut rng).take(len).collect::<String>();
+                            fs.insert_file(&path, content.into_bytes()).await;
+
+                            let server_id = match language_server_ids.iter().choose(&mut rng) {
+                                Some(server_id) if rng.gen_bool(0.5) => *server_id,
+                                _ => {
+                                    let id = LanguageServerId(language_server_ids.len());
+                                    language_server_ids.push(id);
+                                    id
+                                }
+                            };
+
+                            (
+                                path.clone(),
+                                server_id,
+                                current_diagnostics.entry((path, server_id)).or_default(),
+                            )
+                        }
+                    };
+
+                updated_language_servers.insert(server_id);
+
+                lsp_store.update(cx, |lsp_store, cx| {
+                    log::info!("updating diagnostics. language server {server_id} path {path:?}");
+                    randomly_update_diagnostics_for_path(
+                        &fs,
+                        &path,
+                        diagnostics,
+                        &mut next_id,
+                        &mut rng,
+                    );
+                    lsp_store
+                        .update_diagnostics(
+                            server_id,
+                            lsp::PublishDiagnosticsParams {
+                                uri: lsp::Url::from_file_path(&path).unwrap_or_else(|_| {
+                                    lsp::Url::parse("file:///test/fallback.rs").unwrap()
+                                }),
+                                diagnostics: diagnostics.clone(),
+                                version: None,
+                            },
+                            &[],
+                            cx,
+                        )
+                        .unwrap()
+                });
+                cx.executor()
+                    .advance_clock(DIAGNOSTICS_UPDATE_DELAY + Duration::from_millis(10));
+
+                cx.run_until_parked();
+            }
+        }
+    }
+
+    log::info!("updating mutated diagnostics view");
+    mutated_diagnostics.update_in(cx, |diagnostics, window, cx| {
+        diagnostics.update_stale_excerpts(window, cx)
+    });
+
+    cx.executor()
+        .advance_clock(DIAGNOSTICS_UPDATE_DELAY + Duration::from_millis(10));
+    cx.run_until_parked();
+}
+
 #[gpui::test]
 async fn active_diagnostics_dismiss_after_invalidation(cx: &mut TestAppContext) {
    init_test(cx);
--- a/crates/diagnostics/src/items.rs
+++ b/crates/diagnostics/src/items.rs
@@ -9,7 +9,7 @@ use language::Diagnostic;
 use ui::{Button, ButtonLike, Color, Icon, IconName, Label, Tooltip, h_flex, prelude::*};
 use workspace::{StatusItemView, ToolbarItemEvent, Workspace, item::ItemHandle};

-use crate::{Deploy, ProjectDiagnosticsEditor};
+use crate::{Deploy, IncludeWarnings, ProjectDiagnosticsEditor};

 pub struct DiagnosticIndicator {
    summary: project::DiagnosticSummary,
@@ -94,6 +94,11 @@ impl Render for DiagnosticIndicator {
                    })
                    .on_click(cx.listener(|this, _, window, cx| {
                        if let Some(workspace) = this.workspace.upgrade() {
+                            if this.summary.error_count == 0 && this.summary.warning_count > 0 {
+                                cx.update_default_global(
+                                    |show_warnings: &mut IncludeWarnings, _| show_warnings.0 = true,
+                                );
+                            }
                            workspace.update(cx, |workspace, cx| {
                                ProjectDiagnosticsEditor::deploy(
                                    workspace,
--- a/crates/editor/src/actions.rs
+++ b/crates/editor/src/actions.rs
@@ -306,6 +306,8 @@ actions!(
        GoToPreviousHunk,
        GoToImplementation,
        GoToImplementationSplit,
+        GoToNextChange,
+        GoToPreviousChange,
        GoToPreviousDiagnostic,
        GoToTypeDefinition,
        GoToTypeDefinitionSplit,
--- a/crates/editor/src/display_map.rs
+++ b/crates/editor/src/display_map.rs
@@ -49,8 +49,8 @@ use language::{
 };
 use lsp::DiagnosticSeverity;
 use multi_buffer::{
-    Anchor, AnchorRangeExt, MultiBuffer, MultiBufferPoint, MultiBufferRow, MultiBufferSnapshot,
-    RowInfo, ToOffset, ToPoint,
+    Anchor, AnchorRangeExt, ExcerptId, MultiBuffer, MultiBufferPoint, MultiBufferRow,
+    MultiBufferSnapshot, RowInfo, ToOffset, ToPoint,
 };
 use serde::Deserialize;
 use std::{
@@ -574,6 +574,21 @@ impl DisplayMap {
        self.block_map.read(snapshot, edits);
    }

+    pub fn remove_inlays_for_excerpts(&mut self, excerpts_removed: &[ExcerptId]) {
+        let to_remove = self
+            .inlay_map
+            .current_inlays()
+            .filter_map(|inlay| {
+                if excerpts_removed.contains(&inlay.position.excerpt_id) {
+                    Some(inlay.id)
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>();
+        self.inlay_map.splice(&to_remove, Vec::new());
+    }
+
    fn tab_size(buffer: &Entity<MultiBuffer>, cx: &App) -> NonZeroU32 {
        let buffer = buffer.read(cx).as_singleton().map(|buffer| buffer.read(cx));
        let language = buffer
--- a/crates/editor/src/display_map/inlay_map.rs
+++ b/crates/editor/src/display_map/inlay_map.rs
@@ -36,7 +36,7 @@ enum Transform {

 #[derive(Debug, Clone)]
 pub struct Inlay {
-    pub(crate) id: InlayId,
+    pub id: InlayId,
    pub position: Anchor,
    pub text: text::Rope,
 }
@@ -482,6 +482,9 @@ impl InlayMap {
                };

                for inlay in &self.inlays[start_ix..] {
+                    if !inlay.position.is_valid(&buffer_snapshot) {
+                        continue;
+                    }
                    let buffer_offset = inlay.position.to_offset(&buffer_snapshot);
                    if buffer_offset > buffer_edit.new.end {
                        break;
@@ -494,9 +497,7 @@ impl InlayMap {
                        buffer_snapshot.text_summary_for_range(prefix_start..prefix_end),
                    );

-                    if inlay.position.is_valid(&buffer_snapshot) {
-                        new_transforms.push(Transform::Inlay(inlay.clone()), &());
-                    }
+                    new_transforms.push(Transform::Inlay(inlay.clone()), &());
                }

                // Apply the rest of the edit.
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -693,6 +693,52 @@ pub trait Addon: 'static {
    fn to_any(&self) -> &dyn std::any::Any;
 }

+/// A set of caret positions, registered when the editor was edited.
+pub struct ChangeList {
+    changes: Vec<Vec<Anchor>>,
+    /// Currently "selected" change.
+    position: Option<usize>,
+}
+
+impl ChangeList {
+    pub fn new() -> Self {
+        Self {
+            changes: Vec::new(),
+            position: None,
+        }
+    }
+
+    /// Moves to the next change in the list (based on the direction given) and returns the caret positions for the next change.
+    /// If reaches the end of the list in the direction, returns the corresponding change until called for a different direction.
+    pub fn next_change(&mut self, count: usize, direction: Direction) -> Option<&[Anchor]> {
+        if self.changes.is_empty() {
+            return None;
+        }
+
+        let prev = self.position.unwrap_or(self.changes.len());
+        let next = if direction == Direction::Prev {
+            prev.saturating_sub(count)
+        } else {
+            (prev + count).min(self.changes.len() - 1)
+        };
+        self.position = Some(next);
+        self.changes.get(next).map(|anchors| anchors.as_slice())
+    }
+
+    /// Adds a new change to the list, resetting the change list position.
+    pub fn push_to_change_list(&mut self, pop_state: bool, new_positions: Vec<Anchor>) {
+        self.position.take();
+        if pop_state {
+            self.changes.pop();
+        }
+        self.changes.push(new_positions.clone());
+    }
+
+    pub fn last(&self) -> Option<&[Anchor]> {
+        self.changes.last().map(|anchors| anchors.as_slice())
+    }
+}
+
 /// Zed's primary implementation of text input, allowing users to edit a [`MultiBuffer`].
 ///
 /// See the [module level documentation](self) for more information.
@@ -765,6 +811,7 @@ pub struct Editor {
    next_completion_id: CompletionId,
    available_code_actions: Option<(Location, Rc<[AvailableCodeAction]>)>,
    code_actions_task: Option<Task<Result<()>>>,
+    force_code_action_task: bool,
    selection_highlight_task: Option<Task<()>>,
    document_highlights_task: Option<Task<()>>,
    linked_editing_range_task: Option<Task<Option<()>>>,
@@ -857,6 +904,7 @@ pub struct Editor {
    serialize_folds: Task<()>,
    mouse_cursor_hidden: bool,
    hide_mouse_mode: HideMouseMode,
+    pub change_list: ChangeList,
 }

 #[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
@@ -1543,6 +1591,7 @@ impl Editor {
            code_action_providers,
            available_code_actions: Default::default(),
            code_actions_task: Default::default(),
+            force_code_action_task: false,
            selection_highlight_task: Default::default(),
            document_highlights_task: Default::default(),
            linked_editing_range_task: Default::default(),
@@ -1648,6 +1697,7 @@ impl Editor {
            hide_mouse_mode: EditorSettings::get_global(cx)
                .hide_mouse
                .unwrap_or_default(),
+            change_list: ChangeList::new(),
        };
        if let Some(breakpoints) = this.breakpoint_store.as_ref() {
            this._subscriptions
@@ -1661,8 +1711,8 @@ impl Editor {
        this._subscriptions.push(cx.subscribe_in(
            &cx.entity(),
            window,
-            |editor, _, e: &EditorEvent, window, cx| {
-                if let EditorEvent::SelectionsChanged { local } = e {
+            |editor, _, e: &EditorEvent, window, cx| match e {
+                EditorEvent::ScrollPositionChanged { local, .. } => {
                    if *local {
                        let new_anchor = editor.scroll_manager.anchor();
                        let snapshot = editor.snapshot(window, cx);
@@ -1674,6 +1724,30 @@ impl Editor {
                        });
                    }
                }
+                EditorEvent::Edited { .. } => {
+                    if !vim_enabled(cx) {
+                        let (map, selections) = editor.selections.all_adjusted_display(cx);
+                        let pop_state = editor
+                            .change_list
+                            .last()
+                            .map(|previous| {
+                                previous.len() == selections.len()
+                                    && previous.iter().enumerate().all(|(ix, p)| {
+                                        p.to_display_point(&map).row()
+                                            == selections[ix].head().row()
+                                    })
+                            })
+                            .unwrap_or(false);
+                        let new_positions = selections
+                            .into_iter()
+                            .map(|s| map.display_point_to_anchor(s.head(), Bias::Left))
+                            .collect();
+                        editor
+                            .change_list
+                            .push_to_change_list(pop_state, new_positions);
+                    }
+                }
+                _ => (),
            },
        ));

@@ -4170,10 +4244,13 @@ impl Editor {
                if let Some(InlaySplice {
                    to_remove,
                    to_insert,
-                }) = self.inlay_hint_cache.remove_excerpts(excerpts_removed)
+                }) = self.inlay_hint_cache.remove_excerpts(&excerpts_removed)
                {
                    self.splice_inlays(&to_remove, to_insert, cx);
                }
+                self.display_map.update(cx, |display_map, _| {
+                    display_map.remove_inlays_for_excerpts(&excerpts_removed)
+                });
                return;
            }
            InlayHintRefreshReason::NewLinesShown => (InvalidationStrategy::None, None),
@@ -4737,8 +4814,8 @@ impl Editor {
        let lookahead = replace_range
            .end
            .saturating_sub(newest_anchor.end.text_anchor.to_offset(buffer));
-        let prefix = &old_text[..old_text.len() - lookahead];
-        let suffix = &old_text[lookbehind..];
+        let prefix = &old_text[..old_text.len().saturating_sub(lookahead)];
+        let suffix = &old_text[lookbehind.min(old_text.len())..];

        let selections = self.selections.all::<usize>(cx);
        let mut edits = Vec::new();
@@ -4753,7 +4830,7 @@ impl Editor {

                // if prefix is present, don't duplicate it
                if snapshot.contains_str_at(range.start.saturating_sub(lookbehind), prefix) {
-                    text = &new_text[lookbehind..];
+                    text = &new_text[lookbehind.min(new_text.len())..];

                    // if suffix is also present, mimic the newest cursor and replace it
                    if selection.id != newest_anchor.id
@@ -4857,89 +4934,6 @@ impl Editor {
        }))
    }

-    fn prepare_code_actions_task(
-        &mut self,
-        action: &ToggleCodeActions,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Task<Option<(Entity<Buffer>, CodeActionContents)>> {
-        let snapshot = self.snapshot(window, cx);
-        let multibuffer_point = action
-            .deployed_from_indicator
-            .map(|row| DisplayPoint::new(row, 0).to_point(&snapshot))
-            .unwrap_or_else(|| self.selections.newest::<Point>(cx).head());
-
-        let Some((buffer, buffer_row)) = snapshot
-            .buffer_snapshot
-            .buffer_line_for_row(MultiBufferRow(multibuffer_point.row))
-            .and_then(|(buffer_snapshot, range)| {
-                self.buffer
-                    .read(cx)
-                    .buffer(buffer_snapshot.remote_id())
-                    .map(|buffer| (buffer, range.start.row))
-            })
-        else {
-            return Task::ready(None);
-        };
-
-        let (_, code_actions) = self
-            .available_code_actions
-            .clone()
-            .and_then(|(location, code_actions)| {
-                let snapshot = location.buffer.read(cx).snapshot();
-                let point_range = location.range.to_point(&snapshot);
-                let point_range = point_range.start.row..=point_range.end.row;
-                if point_range.contains(&buffer_row) {
-                    Some((location, code_actions))
-                } else {
-                    None
-                }
-            })
-            .unzip();
-
-        let buffer_id = buffer.read(cx).remote_id();
-        let tasks = self
-            .tasks
-            .get(&(buffer_id, buffer_row))
-            .map(|t| Arc::new(t.to_owned()));
-
-        if tasks.is_none() && code_actions.is_none() {
-            return Task::ready(None);
-        }
-
-        self.completion_tasks.clear();
-        self.discard_inline_completion(false, cx);
-
-        let task_context = tasks
-            .as_ref()
-            .zip(self.project.clone())
-            .map(|(tasks, project)| {
-                Self::build_tasks_context(&project, &buffer, buffer_row, tasks, cx)
-            });
-
-        cx.spawn_in(window, async move |_, _| {
-            let task_context = match task_context {
-                Some(task_context) => task_context.await,
-                None => None,
-            };
-            let resolved_tasks = tasks.zip(task_context).map(|(tasks, task_context)| {
-                Rc::new(ResolvedTasks {
-                    templates: tasks.resolve(&task_context).collect(),
-                    position: snapshot
-                        .buffer_snapshot
-                        .anchor_before(Point::new(multibuffer_point.row, tasks.column)),
-                })
-            });
-            Some((
-                buffer,
-                CodeActionContents {
-                    actions: code_actions,
-                    tasks: resolved_tasks,
-                },
-            ))
-        })
-    }
-
    pub fn toggle_code_actions(
        &mut self,
        action: &ToggleCodeActions,
@@ -4960,48 +4954,106 @@ impl Editor {
            }
        }
        drop(context_menu);
-
+        let snapshot = self.snapshot(window, cx);
        let deployed_from_indicator = action.deployed_from_indicator;
        let mut task = self.code_actions_task.take();
        let action = action.clone();
-
        cx.spawn_in(window, async move |editor, cx| {
            while let Some(prev_task) = task {
                prev_task.await.log_err();
                task = editor.update(cx, |this, _| this.code_actions_task.take())?;
            }

-            let context_menu_task = editor.update_in(cx, |editor, window, cx| {
-                if !editor.focus_handle.is_focused(window) {
-                    return Some(Task::ready(Ok(())));
-                }
-                let debugger_flag = cx.has_flag::<Debugger>();
-                let code_actions_task = editor.prepare_code_actions_task(&action, window, cx);
-                Some(cx.spawn_in(window, async move |editor, cx| {
-                    if let Some((buffer, code_action_contents)) = code_actions_task.await {
-                        let spawn_straight_away =
-                            code_action_contents.tasks.as_ref().map_or(false, |tasks| {
-                                tasks
-                                    .templates
-                                    .iter()
-                                    .filter(|task| {
-                                        if matches!(task.1.task_type(), task::TaskType::Debug(_)) {
-                                            debugger_flag
-                                        } else {
-                                            true
-                                        }
-                                    })
-                                    .count()
-                                    == 1
-                            }) && code_action_contents
-                                .actions
-                                .as_ref()
-                                .map_or(true, |actions| actions.is_empty());
+            let spawned_test_task = editor.update_in(cx, |editor, window, cx| {
+                if editor.focus_handle.is_focused(window) {
+                    let multibuffer_point = action
+                        .deployed_from_indicator
+                        .map(|row| DisplayPoint::new(row, 0).to_point(&snapshot))
+                        .unwrap_or_else(|| editor.selections.newest::<Point>(cx).head());
+                    let (buffer, buffer_row) = snapshot
+                        .buffer_snapshot
+                        .buffer_line_for_row(MultiBufferRow(multibuffer_point.row))
+                        .and_then(|(buffer_snapshot, range)| {
+                            editor
+                                .buffer
+                                .read(cx)
+                                .buffer(buffer_snapshot.remote_id())
+                                .map(|buffer| (buffer, range.start.row))
+                        })?;
+                    let (_, code_actions) = editor
+                        .available_code_actions
+                        .clone()
+                        .and_then(|(location, code_actions)| {
+                            let snapshot = location.buffer.read(cx).snapshot();
+                            let point_range = location.range.to_point(&snapshot);
+                            let point_range = point_range.start.row..=point_range.end.row;
+                            if point_range.contains(&buffer_row) {
+                                Some((location, code_actions))
+                            } else {
+                                None
+                            }
+                        })
+                        .unzip();
+                    let buffer_id = buffer.read(cx).remote_id();
+                    let tasks = editor
+                        .tasks
+                        .get(&(buffer_id, buffer_row))
+                        .map(|t| Arc::new(t.to_owned()));
+                    if tasks.is_none() && code_actions.is_none() {
+                        return None;
+                    }
+
+                    editor.completion_tasks.clear();
+                    editor.discard_inline_completion(false, cx);
+                    let task_context =
+                        tasks
+                            .as_ref()
+                            .zip(editor.project.clone())
+                            .map(|(tasks, project)| {
+                                Self::build_tasks_context(&project, &buffer, buffer_row, tasks, cx)
+                            });
+
+                    let debugger_flag = cx.has_flag::<Debugger>();
+
+                    Some(cx.spawn_in(window, async move |editor, cx| {
+                        let task_context = match task_context {
+                            Some(task_context) => task_context.await,
+                            None => None,
+                        };
+                        let resolved_tasks =
+                            tasks.zip(task_context).map(|(tasks, task_context)| {
+                                Rc::new(ResolvedTasks {
+                                    templates: tasks.resolve(&task_context).collect(),
+                                    position: snapshot.buffer_snapshot.anchor_before(Point::new(
+                                        multibuffer_point.row,
+                                        tasks.column,
+                                    )),
+                                })
+                            });
+                        let spawn_straight_away = resolved_tasks.as_ref().map_or(false, |tasks| {
+                            tasks
+                                .templates
+                                .iter()
+                                .filter(|task| {
+                                    if matches!(task.1.task_type(), task::TaskType::Debug(_)) {
+                                        debugger_flag
+                                    } else {
+                                        true
+                                    }
+                                })
+                                .count()
+                                == 1
+                        }) && code_actions
+                            .as_ref()
+                            .map_or(true, |actions| actions.is_empty());
                        if let Ok(task) = editor.update_in(cx, |editor, window, cx| {
                            *editor.context_menu.borrow_mut() =
                                Some(CodeContextMenu::CodeActions(CodeActionsMenu {
                                    buffer,
-                                    actions: code_action_contents,
+                                    actions: CodeActionContents {
+                                        tasks: resolved_tasks,
+                                        actions: code_actions,
+                                    },
                                    selected_item: Default::default(),
                                    scroll_handle: UniformListScrollHandle::default(),
                                    deployed_from_indicator,
@@ -5026,12 +5078,12 @@ impl Editor {
                        } else {
                            Ok(())
                        }
-                    } else {
-                        Ok(())
-                    }
-                }))
+                    }))
+                } else {
+                    Some(Task::ready(Ok(())))
+                }
            })?;
-            if let Some(task) = context_menu_task {
+            if let Some(task) = spawned_test_task {
                task.await?;
            }

@@ -5050,10 +5102,10 @@ impl Editor {

        let (action, buffer) = if action.from_mouse_context_menu {
            if let Some(menu) = self.mouse_context_menu.take() {
-                let code_action = menu.code_action?;
+                let code_action_state = menu.code_action_state?;
                let index = action.item_ix?;
-                let action = code_action.actions.get(index)?;
-                (action, code_action.buffer)
+                let action = code_action_state.contents.get(index)?;
+                (action, code_action_state.buffer)
            } else {
                return None;
            }
@@ -5273,11 +5325,14 @@ impl Editor {
        if start_buffer != end_buffer {
            return None;
        }
+        let force_code_action_task = self.force_code_action_task;

        self.code_actions_task = Some(cx.spawn_in(window, async move |this, cx| {
-            cx.background_executor()
-                .timer(CODE_ACTIONS_DEBOUNCE_TIMEOUT)
-                .await;
+            if !force_code_action_task {
+                cx.background_executor()
+                    .timer(CODE_ACTIONS_DEBOUNCE_TIMEOUT)
+                    .await;
+            }

            let (providers, tasks) = this.update_in(cx, |this, window, cx| {
                let providers = this.code_action_providers.clone();
@@ -12519,6 +12574,45 @@ impl Editor {
            .iter()
            .map(|selection| {
                let old_range = selection.start..selection.end;
+
+                if let Some((node, _)) = buffer.syntax_ancestor(old_range.clone()) {
+                    // manually select word at selection
+                    if ["string_content", "inline"].contains(&node.kind()) {
+                        let word_range = {
+                            let display_point = buffer
+                                .offset_to_point(old_range.start)
+                                .to_display_point(&display_map);
+                            let Range { start, end } =
+                                movement::surrounding_word(&display_map, display_point);
+                            start.to_point(&display_map).to_offset(&buffer)
+                                ..end.to_point(&display_map).to_offset(&buffer)
+                        };
+                        // ignore if word is already selected
+                        if !word_range.is_empty() && old_range != word_range {
+                            let last_word_range = {
+                                let display_point = buffer
+                                    .offset_to_point(old_range.end)
+                                    .to_display_point(&display_map);
+                                let Range { start, end } =
+                                    movement::surrounding_word(&display_map, display_point);
+                                start.to_point(&display_map).to_offset(&buffer)
+                                    ..end.to_point(&display_map).to_offset(&buffer)
+                            };
+                            // only select word if start and end point belongs to same word
+                            if word_range == last_word_range {
+                                selected_larger_node = true;
+                                return Selection {
+                                    id: selection.id,
+                                    start: word_range.start,
+                                    end: word_range.end,
+                                    goal: SelectionGoal::None,
+                                    reversed: selection.reversed,
+                                };
+                            }
+                        }
+                    }
+                }
+
                let mut new_range = old_range.clone();
                let mut new_node = None;
                while let Some((node, containing_range)) = buffer.syntax_ancestor(new_range.clone())
@@ -13261,6 +13355,48 @@ impl Editor {
            .or_else(|| snapshot.buffer_snapshot.diff_hunk_before(Point::MAX))
    }

+    fn go_to_next_change(
+        &mut self,
+        _: &GoToNextChange,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if let Some(selections) = self
+            .change_list
+            .next_change(1, Direction::Next)
+            .map(|s| s.to_vec())
+        {
+            self.change_selections(Some(Autoscroll::fit()), window, cx, |s| {
+                let map = s.display_map();
+                s.select_display_ranges(selections.iter().map(|a| {
+                    let point = a.to_display_point(&map);
+                    point..point
+                }))
+            })
+        }
+    }
+
+    fn go_to_previous_change(
+        &mut self,
+        _: &GoToPreviousChange,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if let Some(selections) = self
+            .change_list
+            .next_change(1, Direction::Prev)
+            .map(|s| s.to_vec())
+        {
+            self.change_selections(Some(Autoscroll::fit()), window, cx, |s| {
+                let map = s.display_map();
+                s.select_display_ranges(selections.iter().map(|a| {
+                    let point = a.to_display_point(&map);
+                    point..point
+                }))
+            })
+        }
+    }
+
    fn go_to_line<T: 'static>(
        &mut self,
        position: Anchor,
@@ -13723,8 +13859,6 @@ impl Editor {
        window: &mut Window,
        cx: &mut Context<Self>,
    ) -> Option<Task<Result<Navigated>>> {
-        self.hide_mouse_cursor(&HideMouseCursorOrigin::TypingAction);
-
        let selection = self.selections.newest::<usize>(cx);
        let multi_buffer = self.buffer.read(cx);
        let head = selection.head();
@@ -17671,11 +17805,7 @@ impl Editor {
            .and_then(|e| e.to_str())
            .map(|a| a.to_string()));

-        let vim_mode = cx
-            .global::<SettingsStore>()
-            .raw_user_settings()
-            .get("vim_mode")
-            == Some(&serde_json::Value::Bool(true));
+        let vim_mode = vim_enabled(cx);

        let edit_predictions_provider = all_language_settings(file, cx).edit_predictions.provider;
        let copilot_enabled = edit_predictions_provider
@@ -18121,6 +18251,13 @@ impl Editor {
    }
 }

+fn vim_enabled(cx: &App) -> bool {
+    cx.global::<SettingsStore>()
+        .raw_user_settings()
+        .get("vim_mode")
+        == Some(&serde_json::Value::Bool(true))
+}
+
 // Consider user intent and default settings
 fn choose_completion_range(
    completion: &Completion,
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -6309,7 +6309,187 @@ async fn test_select_larger_smaller_syntax_node(cx: &mut TestAppContext) {
                use mod1::mod2::«{mod3, mod4}ˇ»;

                fn fn_1«ˇ(param1: bool, param2: &str)» {
-                    «ˇlet var1 = "text";»
+                    let var1 = "«ˇtext»";
+                }
+            "#},
+            cx,
+        );
+    });
+}
+
+#[gpui::test]
+async fn test_select_larger_smaller_syntax_node_for_string(cx: &mut TestAppContext) {
+    init_test(cx, |_| {});
+
+    let language = Arc::new(Language::new(
+        LanguageConfig::default(),
+        Some(tree_sitter_rust::LANGUAGE.into()),
+    ));
+
+    let text = r#"
+        use mod1::mod2::{mod3, mod4};
+
+        fn fn_1(param1: bool, param2: &str) {
+            let var1 = "hello world";
+        }
+    "#
+    .unindent();
+
+    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(language, cx));
+    let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
+    let (editor, cx) = cx.add_window_view(|window, cx| build_editor(buffer, window, cx));
+
+    editor
+        .condition::<crate::EditorEvent>(cx, |editor, cx| !editor.buffer.read(cx).is_parsing(cx))
+        .await;
+
+    // Test 1: Cursor on a letter of a string word
+    editor.update_in(cx, |editor, window, cx| {
+        editor.change_selections(None, window, cx, |s| {
+            s.select_display_ranges([
+                DisplayPoint::new(DisplayRow(3), 17)..DisplayPoint::new(DisplayRow(3), 17)
+            ]);
+        });
+    });
+    editor.update_in(cx, |editor, window, cx| {
+        assert_text_with_selections(
+            editor,
+            indoc! {r#"
+                use mod1::mod2::{mod3, mod4};
+
+                fn fn_1(param1: bool, param2: &str) {
+                    let var1 = "hˇello world";
+                }
+            "#},
+            cx,
+        );
+        editor.select_larger_syntax_node(&SelectLargerSyntaxNode, window, cx);
+        assert_text_with_selections(
+            editor,
+            indoc! {r#"
+                use mod1::mod2::{mod3, mod4};
+
+                fn fn_1(param1: bool, param2: &str) {
+                    let var1 = "«ˇhello» world";
+                }
+            "#},
+            cx,
+        );
+    });
+
+    // Test 2: Partial selection within a word
+    editor.update_in(cx, |editor, window, cx| {
+        editor.change_selections(None, window, cx, |s| {
+            s.select_display_ranges([
+                DisplayPoint::new(DisplayRow(3), 17)..DisplayPoint::new(DisplayRow(3), 19)
+            ]);
+        });
+    });
+    editor.update_in(cx, |editor, window, cx| {
+        assert_text_with_selections(
+            editor,
+            indoc! {r#"
+                use mod1::mod2::{mod3, mod4};
+
+                fn fn_1(param1: bool, param2: &str) {
+                    let var1 = "h«elˇ»lo world";
+                }
+            "#},
+            cx,
+        );
+        editor.select_larger_syntax_node(&SelectLargerSyntaxNode, window, cx);
+        assert_text_with_selections(
+            editor,
+            indoc! {r#"
+                use mod1::mod2::{mod3, mod4};
+
+                fn fn_1(param1: bool, param2: &str) {
+                    let var1 = "«ˇhello» world";
+                }
+            "#},
+            cx,
+        );
+    });
+
+    // Test 3: Complete word already selected
+    editor.update_in(cx, |editor, window, cx| {
+        editor.change_selections(None, window, cx, |s| {
+            s.select_display_ranges([
+                DisplayPoint::new(DisplayRow(3), 16)..DisplayPoint::new(DisplayRow(3), 21)
+            ]);
+        });
+    });
+    editor.update_in(cx, |editor, window, cx| {
+        assert_text_with_selections(
+            editor,
+            indoc! {r#"
+                use mod1::mod2::{mod3, mod4};
+
+                fn fn_1(param1: bool, param2: &str) {
+                    let var1 = "«helloˇ» world";
+                }
+            "#},
+            cx,
+        );
+        editor.select_larger_syntax_node(&SelectLargerSyntaxNode, window, cx);
+        assert_text_with_selections(
+            editor,
+            indoc! {r#"
+                use mod1::mod2::{mod3, mod4};
+
+                fn fn_1(param1: bool, param2: &str) {
+                    let var1 = "«hello worldˇ»";
+                }
+            "#},
+            cx,
+        );
+    });
+
+    // Test 4: Selection spanning across words
+    editor.update_in(cx, |editor, window, cx| {
+        editor.change_selections(None, window, cx, |s| {
+            s.select_display_ranges([
+                DisplayPoint::new(DisplayRow(3), 19)..DisplayPoint::new(DisplayRow(3), 24)
+            ]);
+        });
+    });
+    editor.update_in(cx, |editor, window, cx| {
+        assert_text_with_selections(
+            editor,
+            indoc! {r#"
+                use mod1::mod2::{mod3, mod4};
+
+                fn fn_1(param1: bool, param2: &str) {
+                    let var1 = "hel«lo woˇ»rld";
+                }
+            "#},
+            cx,
+        );
+        editor.select_larger_syntax_node(&SelectLargerSyntaxNode, window, cx);
+        assert_text_with_selections(
+            editor,
+            indoc! {r#"
+                use mod1::mod2::{mod3, mod4};
+
+                fn fn_1(param1: bool, param2: &str) {
+                    let var1 = "«ˇhello world»";
+                }
+            "#},
+            cx,
+        );
+    });
+
+    // Test 5: Expansion beyond string
+    editor.update_in(cx, |editor, window, cx| {
+        editor.select_larger_syntax_node(&SelectLargerSyntaxNode, window, cx);
+        editor.select_larger_syntax_node(&SelectLargerSyntaxNode, window, cx);
+        assert_text_with_selections(
+            editor,
+            indoc! {r#"
+                use mod1::mod2::{mod3, mod4};
+
+                fn fn_1(param1: bool, param2: &str) {
+                    «ˇlet var1 = "hello world";»
                }
            "#},
            cx,
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -435,6 +435,8 @@ impl EditorElement {
        register_action(editor, window, Editor::stage_and_next);
        register_action(editor, window, Editor::unstage_and_next);
        register_action(editor, window, Editor::expand_all_diff_hunks);
+        register_action(editor, window, Editor::go_to_previous_change);
+        register_action(editor, window, Editor::go_to_next_change);

        register_action(editor, window, |editor, action, window, cx| {
            if let Some(task) = editor.format(action, window, cx) {
--- a/crates/editor/src/inlay_hint_cache.rs
+++ b/crates/editor/src/inlay_hint_cache.rs
@@ -555,12 +555,12 @@ impl InlayHintCache {
    /// Completely forget of certain excerpts that were removed from the multibuffer.
    pub(super) fn remove_excerpts(
        &mut self,
-        excerpts_removed: Vec<ExcerptId>,
+        excerpts_removed: &[ExcerptId],
    ) -> Option<InlaySplice> {
        let mut to_remove = Vec::new();
        for excerpt_to_remove in excerpts_removed {
-            self.update_tasks.remove(&excerpt_to_remove);
-            if let Some(cached_hints) = self.hints.remove(&excerpt_to_remove) {
+            self.update_tasks.remove(excerpt_to_remove);
+            if let Some(cached_hints) = self.hints.remove(excerpt_to_remove) {
                let cached_hints = cached_hints.read();
                to_remove.extend(cached_hints.ordered_hints.iter().copied());
            }
@@ -989,6 +989,16 @@ fn fetch_and_update_hints(
                }

                let buffer = editor.buffer().read(cx).buffer(query.buffer_id)?;
+                if !editor.registered_buffers.contains_key(&query.buffer_id) {
+                    if let Some(project) = editor.project.as_ref() {
+                        project.update(cx, |project, cx| {
+                            editor.registered_buffers.insert(
+                                query.buffer_id,
+                                project.register_buffer_with_language_servers(&buffer, cx),
+                            );
+                        })
+                    }
+                }
                editor
                    .semantics_provider
                    .as_ref()?
--- a/crates/editor/src/mouse_context_menu.rs
+++ b/crates/editor/src/mouse_context_menu.rs
@@ -1,21 +1,18 @@
 use crate::{
    ConfirmCodeAction, Copy, CopyAndTrim, CopyPermalinkToLine, Cut, DebuggerEvaluateSelectedText,
    DisplayPoint, DisplaySnapshot, Editor, FindAllReferences, GoToDeclaration, GoToDefinition,
-    GoToImplementation, GoToTypeDefinition, Paste, Rename, RevealInFileManager, SelectMode,
-    ToDisplayPoint, ToggleCodeActions,
+    GoToImplementation, GoToTypeDefinition, MultiBufferRow, OffsetRangeExt, Paste, Rename,
+    RevealInFileManager, SelectMode, ToDisplayPoint,
    actions::{Format, FormatSelections},
    code_context_menus::CodeActionContents,
    selections_collection::SelectionsCollection,
 };
-use feature_flags::{Debugger, FeatureFlagAppExt as _};
 use gpui::prelude::FluentBuilder;
 use gpui::{
-    Context, DismissEvent, Entity, FocusHandle, Focusable as _, Pixels, Point, Subscription, Task,
-    Window,
+    Context, DismissEvent, Entity, Focusable as _, Pixels, Point, Subscription, Task, Window,
 };
 use std::ops::Range;
 use text::PointUtf16;
-use ui::ContextMenu;
 use util::ResultExt;
 use workspace::OpenInTerminal;

@@ -32,23 +29,18 @@ pub enum MenuPosition {
    },
 }

-pub struct MouseCodeAction {
-    pub actions: CodeActionContents,
+pub struct MouseCodeActionState {
+    pub contents: CodeActionContents,
    pub buffer: Entity<language::Buffer>,
 }

 pub struct MouseContextMenu {
    pub(crate) position: MenuPosition,
    pub(crate) context_menu: Entity<ui::ContextMenu>,
-    pub(crate) code_action: Option<MouseCodeAction>,
+    pub(crate) code_action_state: Option<MouseCodeActionState>,
    _subscription: Subscription,
 }

-enum CodeActionLoadState {
-    Loading,
-    Loaded(CodeActionContents),
-}
-
 impl std::fmt::Debug for MouseContextMenu {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("MouseContextMenu")
@@ -63,7 +55,7 @@ impl MouseContextMenu {
        editor: &mut Editor,
        source: multi_buffer::Anchor,
        position: Point<Pixels>,
-        code_action: Option<MouseCodeAction>,
+        code_action_state: Option<MouseCodeActionState>,
        context_menu: Entity<ui::ContextMenu>,
        window: &mut Window,
        cx: &mut Context<Editor>,
@@ -82,7 +74,7 @@ impl MouseContextMenu {
        return Some(MouseContextMenu::new(
            menu_position,
            context_menu,
-            code_action,
+            code_action_state,
            window,
            cx,
        ));
@@ -91,7 +83,7 @@ impl MouseContextMenu {
    pub(crate) fn new(
        position: MenuPosition,
        context_menu: Entity<ui::ContextMenu>,
-        code_action: Option<MouseCodeAction>,
+        code_action_state: Option<MouseCodeActionState>,
        window: &mut Window,
        cx: &mut Context<Editor>,
    ) -> Self {
@@ -112,7 +104,7 @@ impl MouseContextMenu {
        Self {
            position,
            context_menu,
-            code_action,
+            code_action_state,
            _subscription,
        }
    }
@@ -168,241 +160,212 @@ pub fn deploy_context_menu(
        let buffer = &editor.snapshot(window, cx).buffer_snapshot;
        let anchor = buffer.anchor_before(point.to_point(&display_map));
        if !display_ranges(&display_map, &editor.selections).any(|r| r.contains(&point)) {
+            // We don't need to debounce in case of mouse click
+            editor.force_code_action_task = true;
            // Move the cursor to the clicked location so that dispatched actions make sense
            editor.change_selections(None, window, cx, |s| {
                s.clear_disjoint();
                s.set_pending_anchor_range(anchor..anchor, SelectMode::Character);
            });
+            editor.force_code_action_task = false;
        }

-        let focus = window.focused(cx);
-        let has_reveal_target = editor.target_file(cx).is_some();
-        let has_selections = editor
-            .selections
-            .all::<PointUtf16>(cx)
-            .into_iter()
-            .any(|s| !s.is_empty());
-        let has_git_repo = anchor.buffer_id.is_some_and(|buffer_id| {
-            project
-                .read(cx)
-                .git_store()
-                .read(cx)
-                .repository_and_path_for_buffer_id(buffer_id, cx)
-                .is_some()
-        });
-
-        let evaluate_selection = command_palette_hooks::CommandPaletteFilter::try_global(cx)
-            .map_or(false, |filter| {
-                !filter.is_hidden(&DebuggerEvaluateSelectedText)
-            });
-
-        let menu = build_context_menu(
-            focus,
-            has_selections,
-            has_reveal_target,
-            has_git_repo,
-            evaluate_selection,
-            Some(CodeActionLoadState::Loading),
-            window,
-            cx,
-        );
-
-        set_context_menu(editor, menu, source_anchor, position, None, window, cx);
-
-        let mut actions_task = editor.code_actions_task.take();
+        let mut code_action_task = editor.code_actions_task.take();
        cx.spawn_in(window, async move |editor, cx| {
-            while let Some(prev_task) = actions_task {
+            while let Some(prev_task) = code_action_task {
                prev_task.await.log_err();
-                actions_task = editor.update(cx, |this, _| this.code_actions_task.take())?;
+                code_action_task = editor.update(cx, |this, _| this.code_actions_task.take())?;
            }
-            let action = ToggleCodeActions {
-                deployed_from_indicator: Some(point.row()),
-            };
            let context_menu_task = editor.update_in(cx, |editor, window, cx| {
-                let code_actions_task = editor.prepare_code_actions_task(&action, window, cx);
-                Some(cx.spawn_in(window, async move |editor, cx| {
-                    let code_action_result = code_actions_task.await;
-                    if let Ok(editor_task) = editor.update_in(cx, |editor, window, cx| {
-                        let Some(mouse_context_menu) = editor.mouse_context_menu.take() else {
-                            return Task::ready(Ok::<_, anyhow::Error>(()));
-                        };
-                        if mouse_context_menu
-                            .context_menu
-                            .focus_handle(cx)
-                            .contains_focused(window, cx)
-                        {
-                            window.focus(&editor.focus_handle(cx));
-                        }
-                        drop(mouse_context_menu);
-                        let (state, code_action) =
-                            if let Some((buffer, actions)) = code_action_result {
-                                (
-                                    CodeActionLoadState::Loaded(actions.clone()),
-                                    Some(MouseCodeAction { actions, buffer }),
-                                )
-                            } else {
-                                (
-                                    CodeActionLoadState::Loaded(CodeActionContents::default()),
-                                    None,
-                                )
-                            };
-                        let menu = build_context_menu(
-                            window.focused(cx),
-                            has_selections,
-                            has_reveal_target,
-                            has_git_repo,
-                            evaluate_selection,
-                            Some(state),
-                            window,
-                            cx,
-                        );
-                        set_context_menu(
-                            editor,
-                            menu,
-                            source_anchor,
-                            position,
-                            code_action,
-                            window,
-                            cx,
-                        );
-                        Task::ready(Ok(()))
-                    }) {
-                        editor_task.await
+                let focus = window.focused(cx);
+                let has_reveal_target = editor.target_file(cx).is_some();
+                let has_selections = editor
+                    .selections
+                    .all::<PointUtf16>(cx)
+                    .into_iter()
+                    .any(|s| !s.is_empty());
+                let has_git_repo = anchor.buffer_id.is_some_and(|buffer_id| {
+                    project
+                        .read(cx)
+                        .git_store()
+                        .read(cx)
+                        .repository_and_path_for_buffer_id(buffer_id, cx)
+                        .is_some()
+                });
+
+                let evaluate_selection =
+                    command_palette_hooks::CommandPaletteFilter::try_global(cx)
+                        .map_or(false, |filter| {
+                            !filter.is_hidden(&DebuggerEvaluateSelectedText)
+                        });
+
+                let editor_snapshot = &editor.snapshot(window, cx);
+                let code_action_state = {
+                    if let Some((buffer, buffer_row)) = editor_snapshot
+                        .buffer_snapshot
+                        .buffer_line_for_row(MultiBufferRow(point.to_point(editor_snapshot).row))
+                        .and_then(|(buffer_snapshot, range)| {
+                            editor
+                                .buffer
+                                .read(cx)
+                                .buffer(buffer_snapshot.remote_id())
+                                .map(|buffer| (buffer, range.start.row))
+                        })
+                    {
+                        editor.available_code_actions.clone().and_then(
+                            |(location, code_actions)| {
+                                let snapshot = location.buffer.read(cx).snapshot();
+                                let point_range = location.range.to_point(&snapshot);
+                                let point_range = point_range.start.row..=point_range.end.row;
+                                if point_range.contains(&buffer_row) {
+                                    Some(MouseCodeActionState {
+                                        contents: CodeActionContents {
+                                            actions: Some(code_actions),
+                                            tasks: None,
+                                        },
+                                        buffer,
+                                    })
+                                } else {
+                                    None
+                                }
+                            },
+                        )
                    } else {
-                        Ok(())
+                        None
                    }
-                }))
+                };
+
+                let action_labels = code_action_state
+                    .as_ref()
+                    .map(|state| {
+                        if state.contents.is_empty() {
+                            None
+                        } else {
+                            Some(
+                                state
+                                    .contents
+                                    .iter()
+                                    .map(|item| item.label())
+                                    .collect::<Vec<_>>(),
+                            )
+                        }
+                    })
+                    .flatten();
+
+                let menu = ui::ContextMenu::build(window, cx, |menu, _window, _| {
+                    let menu = menu
+                        .on_blur_subscription(Subscription::new(|| {}))
+                        .when_some(action_labels, |menu, labels| {
+                            menu.map(|menu| {
+                                labels
+                                    .into_iter()
+                                    .enumerate()
+                                    .fold(menu, |menu, (ix, label)| {
+                                        menu.action(
+                                            label,
+                                            Box::new(ConfirmCodeAction {
+                                                item_ix: Some(ix),
+                                                from_mouse_context_menu: true,
+                                            }),
+                                        )
+                                    })
+                            })
+                            .separator()
+                        })
+                        .when(evaluate_selection && has_selections, |builder| {
+                            builder
+                                .action(
+                                    "Evaluate Selection",
+                                    Box::new(DebuggerEvaluateSelectedText),
+                                )
+                                .separator()
+                        })
+                        .action("Go to Definition", Box::new(GoToDefinition))
+                        .action("Go to Declaration", Box::new(GoToDeclaration))
+                        .action("Go to Type Definition", Box::new(GoToTypeDefinition))
+                        .action("Go to Implementation", Box::new(GoToImplementation))
+                        .action("Find All References", Box::new(FindAllReferences))
+                        .separator()
+                        .action("Rename Symbol", Box::new(Rename))
+                        .action("Format Buffer", Box::new(Format))
+                        .when(has_selections, |cx| {
+                            cx.action("Format Selections", Box::new(FormatSelections))
+                        })
+                        .separator()
+                        .action("Cut", Box::new(Cut))
+                        .action("Copy", Box::new(Copy))
+                        .action("Copy and trim", Box::new(CopyAndTrim))
+                        .action("Paste", Box::new(Paste))
+                        .separator()
+                        .map(|builder| {
+                            let reveal_in_finder_label = if cfg!(target_os = "macos") {
+                                "Reveal in Finder"
+                            } else {
+                                "Reveal in File Manager"
+                            };
+                            const OPEN_IN_TERMINAL_LABEL: &str = "Open in Terminal";
+                            if has_reveal_target {
+                                builder
+                                    .action(reveal_in_finder_label, Box::new(RevealInFileManager))
+                                    .action(OPEN_IN_TERMINAL_LABEL, Box::new(OpenInTerminal))
+                            } else {
+                                builder
+                                    .disabled_action(
+                                        reveal_in_finder_label,
+                                        Box::new(RevealInFileManager),
+                                    )
+                                    .disabled_action(
+                                        OPEN_IN_TERMINAL_LABEL,
+                                        Box::new(OpenInTerminal),
+                                    )
+                            }
+                        })
+                        .map(|builder| {
+                            const COPY_PERMALINK_LABEL: &str = "Copy Permalink";
+                            if has_git_repo {
+                                builder.action(COPY_PERMALINK_LABEL, Box::new(CopyPermalinkToLine))
+                            } else {
+                                builder.disabled_action(
+                                    COPY_PERMALINK_LABEL,
+                                    Box::new(CopyPermalinkToLine),
+                                )
+                            }
+                        });
+                    match focus {
+                        Some(focus) => menu.context(focus),
+                        None => menu,
+                    }
+                });
+
+                set_context_menu(
+                    editor,
+                    menu,
+                    source_anchor,
+                    position,
+                    code_action_state,
+                    window,
+                    cx,
+                );
+
+                Some(Task::ready(Ok::<_, anyhow::Error>(())))
            })?;
+
            if let Some(task) = context_menu_task {
                task.await?;
            }
+
            Ok::<_, anyhow::Error>(())
        })
        .detach_and_log_err(cx);
    };
 }

-fn build_context_menu(
-    focus: Option<FocusHandle>,
-    has_selections: bool,
-    has_reveal_target: bool,
-    has_git_repo: bool,
-    evaluate_selection: bool,
-    code_action_load_state: Option<CodeActionLoadState>,
-    window: &mut Window,
-    cx: &mut Context<Editor>,
-) -> Entity<ContextMenu> {
-    ui::ContextMenu::build(window, cx, |menu, _window, cx| {
-        let menu = menu
-            .on_blur_subscription(Subscription::new(|| {}))
-            .when(evaluate_selection && has_selections, |builder| {
-                builder
-                    .action("Evaluate Selection", Box::new(DebuggerEvaluateSelectedText))
-                    .separator()
-            })
-            .action("Go to Definition", Box::new(GoToDefinition))
-            .action("Go to Declaration", Box::new(GoToDeclaration))
-            .action("Go to Type Definition", Box::new(GoToTypeDefinition))
-            .action("Go to Implementation", Box::new(GoToImplementation))
-            .action("Find All References", Box::new(FindAllReferences))
-            .separator()
-            .action("Rename Symbol", Box::new(Rename))
-            .action("Format Buffer", Box::new(Format))
-            .when(has_selections, |cx| {
-                cx.action("Format Selections", Box::new(FormatSelections))
-            })
-            .separator()
-            .action("Cut", Box::new(Cut))
-            .action("Copy", Box::new(Copy))
-            .action("Copy and trim", Box::new(CopyAndTrim))
-            .action("Paste", Box::new(Paste))
-            .separator()
-            .map(|builder| {
-                let reveal_in_finder_label = if cfg!(target_os = "macos") {
-                    "Reveal in Finder"
-                } else {
-                    "Reveal in File Manager"
-                };
-                const OPEN_IN_TERMINAL_LABEL: &str = "Open in Terminal";
-                if has_reveal_target {
-                    builder
-                        .action(reveal_in_finder_label, Box::new(RevealInFileManager))
-                        .action(OPEN_IN_TERMINAL_LABEL, Box::new(OpenInTerminal))
-                } else {
-                    builder
-                        .disabled_action(reveal_in_finder_label, Box::new(RevealInFileManager))
-                        .disabled_action(OPEN_IN_TERMINAL_LABEL, Box::new(OpenInTerminal))
-                }
-            })
-            .map(|builder| {
-                const COPY_PERMALINK_LABEL: &str = "Copy Permalink";
-                if has_git_repo {
-                    builder.action(COPY_PERMALINK_LABEL, Box::new(CopyPermalinkToLine))
-                } else {
-                    builder.disabled_action(COPY_PERMALINK_LABEL, Box::new(CopyPermalinkToLine))
-                }
-            })
-            .when_some(code_action_load_state, |menu, state| {
-                menu.separator().map(|menu| match state {
-                    CodeActionLoadState::Loading => menu.disabled_action(
-                        "Loading code actions...",
-                        Box::new(ConfirmCodeAction {
-                            item_ix: None,
-                            from_mouse_context_menu: true,
-                        }),
-                    ),
-                    CodeActionLoadState::Loaded(actions) => {
-                        if actions.is_empty() {
-                            menu.disabled_action(
-                                "No code actions available",
-                                Box::new(ConfirmCodeAction {
-                                    item_ix: None,
-                                    from_mouse_context_menu: true,
-                                }),
-                            )
-                        } else {
-                            actions
-                                .iter()
-                                .filter(|action| {
-                                    if action
-                                        .as_task()
-                                        .map(|task| {
-                                            matches!(task.task_type(), task::TaskType::Debug(_))
-                                        })
-                                        .unwrap_or(false)
-                                    {
-                                        cx.has_flag::<Debugger>()
-                                    } else {
-                                        true
-                                    }
-                                })
-                                .enumerate()
-                                .fold(menu, |menu, (ix, action)| {
-                                    menu.action(
-                                        action.label(),
-                                        Box::new(ConfirmCodeAction {
-                                            item_ix: Some(ix),
-                                            from_mouse_context_menu: true,
-                                        }),
-                                    )
-                                })
-                        }
-                    }
-                })
-            });
-        match focus {
-            Some(focus) => menu.context(focus),
-            None => menu,
-        }
-    })
-}
-
 fn set_context_menu(
    editor: &mut Editor,
    context_menu: Entity<ui::ContextMenu>,
    source_anchor: multi_buffer::Anchor,
    position: Option<Point<Pixels>>,
-    code_action: Option<MouseCodeAction>,
+    code_action_state: Option<MouseCodeActionState>,
    window: &mut Window,
    cx: &mut Context<Editor>,
 ) {
@@ -411,7 +374,7 @@ fn set_context_menu(
            editor,
            source_anchor,
            position,
-            code_action,
+            code_action_state,
            context_menu,
            window,
            cx,
@@ -425,7 +388,7 @@ fn set_context_menu(
            Some(MouseContextMenu::new(
                menu_position,
                context_menu,
-                code_action,
+                code_action_state,
                window,
                cx,
            ))
--- a/crates/eval/Cargo.toml
+++ b/crates/eval/Cargo.toml
@@ -16,6 +16,7 @@ client.workspace = true
 collections.workspace = true
 context_server.workspace = true
 dap.workspace = true
+dirs = "5.0"
 env_logger.workspace = true
 extension.workspace = true
 fs.workspace = true
@@ -37,9 +38,11 @@ reqwest_client.workspace = true
 serde.workspace = true
 settings.workspace = true
 shellexpand.workspace = true
+telemetry.workspace = true
 toml.workspace = true
 unindent.workspace = true
 util.workspace = true
+uuid = { version = "1.6", features = ["v4"] }
 workspace-hack.workspace = true

 [[bin]]
--- a/crates/eval/src/eval.rs
+++ b/crates/eval/src/eval.rs
@@ -1,13 +1,16 @@
 mod example;
+mod ids;

 use client::{Client, ProxySettings, UserStore};
 pub(crate) use example::*;
+use telemetry;

 use ::fs::RealFs;
 use anyhow::{Result, anyhow};
 use clap::Parser;
 use extension::ExtensionHostProxy;
 use futures::future;
+use futures::stream::StreamExt;
 use gpui::http_client::{Uri, read_proxy_from_env};
 use gpui::{App, AppContext, Application, AsyncApp, Entity, SemanticVersion, Task, UpdateGlobal};
 use gpui_tokio::Tokio;
@@ -39,9 +42,18 @@ struct Args {
    /// Model to use (default: "claude-3-7-sonnet-latest")
    #[arg(long, default_value = "claude-3-7-sonnet-latest")]
    model: String,
-    /// Languages to run (comma-separated, e.g. "js,ts,py"). If unspecified, only Rust examples are run.
    #[arg(long, value_delimiter = ',')]
    languages: Option<Vec<String>>,
+    /// How many times to run each example. Note that this is currently not very efficient as N
+    /// worktrees will be created for the examples.
+    #[arg(long, default_value = "1")]
+    repetitions: u32,
+    /// How many times to run the judge on each example run.
+    #[arg(long, default_value = "3")]
+    judge_repetitions: u32,
+    /// Maximum number of examples to run concurrently.
+    #[arg(long, default_value = "10")]
+    concurrency: usize,
 }

 fn main() {
@@ -74,6 +86,15 @@ fn main() {
    app.run(move |cx| {
        let app_state = init(cx);

+        let system_id = ids::get_or_create_id(&ids::eval_system_id_path()).ok();
+        let installation_id = ids::get_or_create_id(&ids::eval_installation_id_path()).ok();
+        let session_id = uuid::Uuid::new_v4().to_string();
+
+        app_state
+            .client
+            .telemetry()
+            .start(system_id, installation_id, session_id, cx);
+
        let model = find_model("claude-3-7-sonnet-latest", cx).unwrap();

        LanguageModelRegistry::global(cx).update(cx, |registry, cx| {
@@ -129,12 +150,20 @@ fn main() {
                    continue;
                }

-                let name_len = example.name.len();
-                if name_len > max_name_width {
-                    max_name_width = example.name.len();
-                }
+                // TODO: This creates a worktree per repetition. Ideally these examples should
+                // either be run sequentially on the same worktree, or reuse worktrees when there
+                // are more examples to run than the concurrency limit.
+                for repetition_number in 0..args.repetitions {
+                    let mut example = example.clone();
+                    example.set_repetition_number(repetition_number);

-                examples.push(example);
+                    let name_len = example.name.len();
+                    if name_len > max_name_width {
+                        max_name_width = example.name.len();
+                    }
+
+                    examples.push(example);
+                }
            }

            println!("Skipped examples: {}\n", skipped.join(", "));
@@ -203,18 +232,26 @@ fn main() {
                example.setup().await?;
            }

+            let judge_repetitions = args.judge_repetitions;
+            let concurrency = args.concurrency;
+
            let tasks = examples
                .into_iter()
                .map(|example| {
                    let app_state = app_state.clone();
                    let model = model.clone();
                    cx.spawn(async move |cx| {
-                        (run_example(&example, model, app_state, cx).await, example)
+                        let result =
+                            run_example(&example, model, app_state, judge_repetitions, cx).await;
+                        (result, example)
                    })
                })
                .collect::<Vec<_>>();

-            let results: Vec<(Result<JudgeOutput>, Example)> = future::join_all(tasks).await;
+            let results = futures::stream::iter(tasks)
+                .buffer_unordered(concurrency)
+                .collect::<Vec<(Result<Vec<Result<JudgeOutput>>>, Example)>>()
+                .await;

            println!("\n\n");
            println!("========================================");
@@ -229,16 +266,25 @@ fn main() {
                    Err(err) => {
                        println!("💥 {}{:?}", example.log_prefix, err);
                    }
-                    Ok(judge_output) => {
-                        const SCORES: [&str; 6] = ["💀", "😭", "😔", "😐", "🙂", "🤩"];
+                    Ok(judge_results) => {
+                        for judge_result in judge_results {
+                            match judge_result {
+                                Ok(judge_output) => {
+                                    const SCORES: [&str; 6] = ["💀", "😭", "😔", "😐", "🙂", "🤩"];
+                                    let score: u32 = judge_output.score;
+                                    let score_index = (score.min(5)) as usize;

-                        println!(
-                            "{} {}{}",
-                            SCORES[judge_output.score.min(5) as usize],
-                            example.log_prefix,
-                            judge_output.score,
-                        );
-                        judge_scores.push(judge_output.score);
+                                    println!(
+                                        "{} {}{}",
+                                        SCORES[score_index], example.log_prefix, judge_output.score,
+                                    );
+                                    judge_scores.push(judge_output.score);
+                                }
+                                Err(err) => {
+                                    println!("💥 {}{:?}", example.log_prefix, err);
+                                }
+                            }
+                        }
                    }
                }
                println!(
@@ -256,6 +302,10 @@ fn main() {
                / (score_count as f32);
            println!("\nAverage score: {average_score}");

+            std::thread::sleep(std::time::Duration::from_secs(2));
+
+            app_state.client.telemetry().flush_events();
+
            cx.update(|cx| cx.quit())
        })
        .detach_and_log_err(cx);
@@ -266,12 +316,55 @@ async fn run_example(
    example: &Example,
    model: Arc<dyn LanguageModel>,
    app_state: Arc<AgentAppState>,
+    judge_repetitions: u32,
    cx: &mut AsyncApp,
-) -> Result<JudgeOutput> {
-    cx.update(|cx| example.run(model.clone(), app_state, cx))?
+) -> Result<Vec<Result<JudgeOutput>>> {
+    let run_output = cx
+        .update(|cx| example.run(model.clone(), app_state.clone(), cx))?
        .await?;
    let diff = example.repository_diff().await?;
-    example.judge(model, diff, cx).await
+
+    // Run judge for each repetition
+    let mut results = Vec::new();
+    for round in 0..judge_repetitions {
+        let judge_result = example.judge(model.clone(), diff.clone(), round, cx).await;
+
+        if let Ok(judge_output) = &judge_result {
+            let cohort_id = example
+                .output_file_path
+                .parent()
+                .and_then(|p| p.file_name())
+                .map(|name| name.to_string_lossy().to_string())
+                .unwrap_or(chrono::Local::now().format("%Y-%m-%d_%H-%M-%S").to_string());
+
+            let path = std::path::Path::new(".");
+            let commit_id = get_current_commit_id(path).await.unwrap_or_default();
+
+            telemetry::event!(
+                "Agent Eval Completed",
+                cohort_id = cohort_id,
+                example_name = example.name.clone(),
+                round = round,
+                score = judge_output.score,
+                analysis = judge_output.analysis,
+                tool_use_counts = run_output.tool_use_counts,
+                response_count = run_output.response_count,
+                token_usage = run_output.token_usage,
+                model = model.telemetry_id(),
+                model_provider = model.provider_id().to_string(),
+                repository_url = example.base.url.clone(),
+                repository_revision = example.base.revision.clone(),
+                diagnostics_summary = run_output.diagnostics,
+                commit_id = commit_id
+            );
+        }
+
+        results.push(judge_result);
+    }
+
+    app_state.client.telemetry().flush_events();
+
+    Ok(results)
 }

 fn list_all_examples() -> Result<Vec<PathBuf>> {
@@ -433,3 +526,13 @@ pub fn authenticate_model_provider(
    let model_provider = model_registry.provider(&provider_id).unwrap();
    model_provider.authenticate(cx)
 }
+
+pub async fn get_current_commit_id(repo_path: &Path) -> Option<String> {
+    (run_git(repo_path, &["rev-parse", "HEAD"]).await).ok()
+}
+
+pub fn get_current_commit_id_sync(repo_path: &Path) -> String {
+    futures::executor::block_on(async {
+        get_current_commit_id(repo_path).await.unwrap_or_default()
+    })
+}
--- a/crates/eval/src/example.rs
+++ b/crates/eval/src/example.rs
@@ -58,6 +58,8 @@ pub struct Example {
    pub criteria: String,
    /// Markdown output file to append to
    pub output_file: Option<Arc<Mutex<File>>>,
+    /// Path to the output run directory.
+    pub run_dir: PathBuf,
    /// Path to markdown output file
    pub output_file_path: PathBuf,
    /// Prefix used for logging that identifies this example
@@ -92,23 +94,27 @@ impl Example {
        let base_path = dir_path.join("base.toml");
        let prompt_path = dir_path.join("prompt.md");
        let criteria_path = dir_path.join("criteria.md");
-
-        let output_file_path = run_dir.join(format!(
-            "{}.md",
-            dir_path.file_name().unwrap().to_str().unwrap()
-        ));
+        let output_file_path = run_dir.join(format!("{}.md", name));

        Ok(Example {
            name: name.clone(),
            base: toml::from_str(&fs::read_to_string(&base_path)?)?,
            prompt: fs::read_to_string(prompt_path.clone())?,
            criteria: fs::read_to_string(criteria_path.clone())?,
+            run_dir: run_dir.to_path_buf(),
            output_file: None,
            output_file_path,
            log_prefix: name,
        })
    }

+    pub fn set_repetition_number(&mut self, repetition_number: u32) {
+        if repetition_number > 0 {
+            self.name = format!("{}-{}", self.name, repetition_number);
+            self.output_file_path = self.run_dir.join(format!("{}.md", self.name));
+        }
+    }
+
    pub fn set_log_prefix_style(&mut self, color: &str, name_width: usize) {
        self.log_prefix = format!(
            "{}{:<width$}\x1b[0m | ",
@@ -134,13 +140,21 @@ impl Example {
    pub async fn setup(&mut self) -> Result<()> {
        let repo_path = repo_path_for_url(&self.base.url);

-        println!("{}Fetching", self.log_prefix);
+        let revision_exists = run_git(&repo_path, &["rev-parse", "--verify", &self.base.revision])
+            .await
+            .is_ok();

-        run_git(
-            &repo_path,
-            &["fetch", "--depth", "1", "origin", &self.base.revision],
-        )
-        .await?;
+        if !revision_exists {
+            println!(
+                "{}Fetching revision {}",
+                self.log_prefix, &self.base.revision
+            );
+            run_git(
+                &repo_path,
+                &["fetch", "--depth", "1", "origin", &self.base.revision],
+            )
+            .await?;
+        }

        let worktree_path = self.worktree_path();

@@ -372,18 +386,26 @@ impl Example {
                                pending_tool_use,
                                ..
                            } => {
-                                if let Some(tool_use) = pending_tool_use {
-                                    let message = format!("TOOL FINISHED: {}", tool_use.name);
-                                    println!("{}{message}", log_prefix);
-                                    writeln!(&mut output_file, "\n{}", message).log_err();
-                                }
                                thread.update(cx, |thread, _cx| {
-                                    if let Some(tool_result) = thread.tool_result(&tool_use_id) {
-                                        writeln!(&mut output_file, "\n{}\n", tool_result.content).log_err();
-                                        let mut tool_use_counts = tool_use_counts.lock().unwrap();
-                                        *tool_use_counts
-                                            .entry(tool_result.tool_name.clone())
-                                            .or_insert(0) += 1;
+                                    if let Some(tool_use) = pending_tool_use {
+                                        if let Some(tool_result) = thread.tool_result(&tool_use_id) {
+                                            let message = if tool_result.is_error {
+                                                format!("TOOL FAILED: {}", tool_use.name)
+                                            } else {
+                                                format!("TOOL FINISHED: {}", tool_use.name)
+                                            };
+                                            println!("{log_prefix}{message}");
+                                            writeln!(&mut output_file, "\n{}", message).log_err();
+                                            writeln!(&mut output_file, "\n{}\n", tool_result.content).log_err();
+                                            let mut tool_use_counts = tool_use_counts.lock().unwrap();
+                                            *tool_use_counts
+                                                .entry(tool_result.tool_name.clone())
+                                                .or_insert(0) += 1;
+                                        } else {
+                                            let message = format!("TOOL FINISHED WITHOUT RESULT: {}", tool_use.name);
+                                            println!("{log_prefix}{message}");
+                                            writeln!(&mut output_file, "\n{}", message).log_err();
+                                        }
                                    }
                                })?;
                            }
@@ -425,6 +447,10 @@ impl Example {
            println!("{}Getting repository diff", this.log_prefix);
            let repository_diff = this.repository_diff().await?;

+            let repository_diff_path = this.run_dir.join(format!("{}.diff", this.name));
+            let mut repository_diff_output_file = File::create(&repository_diff_path)?;
+            writeln!(&mut repository_diff_output_file, "{}", &repository_diff).log_err();
+
            println!("{}Getting diagnostics", this.log_prefix);
            let diagnostics = cx
                .update(move |cx| {
@@ -456,6 +482,7 @@ impl Example {
        &self,
        model: Arc<dyn LanguageModel>,
        repository_diff: String,
+        judge_repetitions: u32,
        cx: &AsyncApp,
    ) -> Result<JudgeOutput> {
        let judge_prompt = include_str!("judge_prompt.hbs");
@@ -483,14 +510,14 @@ impl Example {

        let response = send_language_model_request(model, request, cx).await?;

-        let output_file_ref = self.output_file();
-        let mut output_file = output_file_ref.lock().unwrap();
+        let judge_file_path = self.run_dir.join(format!(
+            "{}_judge_{}.md",
+            self.name, // This is the eval_name
+            judge_repetitions
+        ));

-        writeln!(&mut output_file, "\n\n").log_err();
-        writeln!(&mut output_file, "========================================").log_err();
-        writeln!(&mut output_file, "              JUDGE OUTPUT              ").log_err();
-        writeln!(&mut output_file, "========================================").log_err();
-        writeln!(&mut output_file, "\n{}", &response).log_err();
+        let mut judge_output_file = File::create(&judge_file_path)?;
+        writeln!(&mut judge_output_file, "{}", &response).log_err();

        parse_judge_output(&response)
    }
--- a/crates/eval/src/ids.rs
+++ b/crates/eval/src/ids.rs
@@ -0,0 +1,28 @@
+use anyhow::Result;
+use std::fs;
+use std::path::{Path, PathBuf};
+use uuid::Uuid;
+
+pub fn get_or_create_id(path: &Path) -> Result<String> {
+    if let Ok(id) = fs::read_to_string(path) {
+        let trimmed = id.trim();
+        if !trimmed.is_empty() {
+            return Ok(trimmed.to_string());
+        }
+    }
+    let new_id = Uuid::new_v4().to_string();
+    fs::write(path, &new_id)?;
+    Ok(new_id)
+}
+
+pub fn eval_system_id_path() -> PathBuf {
+    dirs::data_local_dir()
+        .unwrap_or_else(|| PathBuf::from("."))
+        .join("zed-eval-system-id")
+}
+
+pub fn eval_installation_id_path() -> PathBuf {
+    dirs::data_local_dir()
+        .unwrap_or_else(|| PathBuf::from("."))
+        .join("zed-eval-installation-id")
+}
--- a/crates/feature_flags/src/feature_flags.rs
+++ b/crates/feature_flags/src/feature_flags.rs
@@ -84,6 +84,11 @@ impl FeatureFlag for ZedPro {
    const NAME: &'static str = "zed-pro";
 }

+pub struct ZedProWebSearchTool {}
+impl FeatureFlag for ZedProWebSearchTool {
+    const NAME: &'static str = "zed-pro-web-search-tool";
+}
+
 pub struct NotebookFeatureFlag;

 impl FeatureFlag for NotebookFeatureFlag {
--- a/crates/feedback/src/feedback.rs
+++ b/crates/feedback/src/feedback.rs
@@ -2,6 +2,7 @@ use gpui::{App, ClipboardItem, PromptLevel, actions};
 use system_specs::SystemSpecs;
 use util::ResultExt;
 use workspace::Workspace;
+use zed_actions::feedback::FileBugReport;

 pub mod feedback_modal;

@@ -12,7 +13,6 @@ actions!(
    [
        CopySystemSpecsIntoClipboard,
        EmailZed,
-        FileBugReport,
        OpenZedRepo,
        RequestFeature,
    ]
@@ -27,7 +27,7 @@ fn file_bug_report_url(specs: &SystemSpecs) -> String {
        concat!(
            "https://github.com/zed-industries/zed/issues/new",
            "?",
-            "template=1_bug_report.yml",
+            "template=10_bug_report.yml",
            "&",
            "environment={}"
        ),
--- a/crates/fs/src/fs.rs
+++ b/crates/fs/src/fs.rs
@@ -1333,13 +1333,23 @@ impl FakeFs {
            let Some((git_dir_entry, canonical_path)) = state.try_read_path(&path, true) else {
                anyhow::bail!("pointed-to git dir {path:?} not found")
            };
-            let FakeFsEntry::Dir { git_repo_state, .. } = &mut *git_dir_entry.lock() else {
+            let FakeFsEntry::Dir {
+                git_repo_state,
+                entries,
+                ..
+            } = &mut *git_dir_entry.lock()
+            else {
                anyhow::bail!("gitfile points to a non-directory")
            };
-            let common_dir = canonical_path
-                .ancestors()
-                .find(|ancestor| ancestor.ends_with(".git"))
-                .ok_or_else(|| anyhow!("repository dir not contained in any .git"))?;
+            let common_dir = if let Some(child) = entries.get("commondir") {
+                Path::new(
+                    std::str::from_utf8(child.lock().file_content("commondir".as_ref())?)
+                        .context("commondir content")?,
+                )
+                .to_owned()
+            } else {
+                canonical_path.clone()
+            };
            let repo_state = git_repo_state.get_or_insert_with(|| {
                Arc::new(Mutex::new(FakeGitRepositoryState::new(
                    state.git_event_tx.clone(),
@@ -1347,7 +1357,7 @@ impl FakeFs {
            });
            let mut repo_state = repo_state.lock();

-            let result = f(&mut repo_state, &canonical_path, common_dir);
+            let result = f(&mut repo_state, &canonical_path, &common_dir);

            if emit_git_event {
                state.emit_event([(canonical_path, None)]);
--- a/crates/git/src/repository.rs
+++ b/crates/git/src/repository.rs
@@ -1013,7 +1013,6 @@ impl GitRepository for RealGitRepository {
            let mut command = new_smol_command("git");
            command
                .envs(env.iter())
-                .env("GIT_HTTP_USER_AGENT", "Zed")
                .current_dir(&working_directory)
                .args(["push"])
                .args(options.map(|option| match option {
@@ -1045,7 +1044,6 @@ impl GitRepository for RealGitRepository {
            let mut command = new_smol_command("git");
            command
                .envs(env.iter())
-                .env("GIT_HTTP_USER_AGENT", "Zed")
                .current_dir(&working_directory?)
                .args(["pull"])
                .arg(remote_name)
@@ -1070,7 +1068,6 @@ impl GitRepository for RealGitRepository {
            let mut command = new_smol_command("git");
            command
                .envs(env.iter())
-                .env("GIT_HTTP_USER_AGENT", "Zed")
                .current_dir(&working_directory?)
                .args(["fetch", "--all"])
                .stdout(smol::process::Stdio::piped())
--- a/crates/git_ui/src/git_panel.rs
+++ b/crates/git_ui/src/git_panel.rs
@@ -599,33 +599,11 @@ impl GitPanel {
    }

    pub fn entry_by_path(&self, path: &RepoPath) -> Option<usize> {
-        fn binary_search<F>(mut low: usize, mut high: usize, is_target: F) -> Option<usize>
-        where
-            F: Fn(usize) -> std::cmp::Ordering,
-        {
-            while low < high {
-                let mid = low + (high - low) / 2;
-                match is_target(mid) {
-                    std::cmp::Ordering::Equal => return Some(mid),
-                    std::cmp::Ordering::Less => low = mid + 1,
-                    std::cmp::Ordering::Greater => high = mid,
-                }
-            }
-            None
-        }
        if self.conflicted_count > 0 {
            let conflicted_start = 1;
-            if let Some(ix) = binary_search(
-                conflicted_start,
-                conflicted_start + self.conflicted_count,
-                |ix| {
-                    self.entries[ix]
-                        .status_entry()
-                        .unwrap()
-                        .repo_path
-                        .cmp(&path)
-                },
-            ) {
+            if let Ok(ix) = self.entries[conflicted_start..conflicted_start + self.conflicted_count]
+                .binary_search_by(|entry| entry.status_entry().unwrap().repo_path.cmp(&path))
+            {
                return Some(ix);
            }
        }
@@ -635,14 +613,8 @@ impl GitPanel {
            } else {
                0
            } + 1;
-            if let Some(ix) =
-                binary_search(tracked_start, tracked_start + self.tracked_count, |ix| {
-                    self.entries[ix]
-                        .status_entry()
-                        .unwrap()
-                        .repo_path
-                        .cmp(&path)
-                })
+            if let Ok(ix) = self.entries[tracked_start..tracked_start + self.tracked_count]
+                .binary_search_by(|entry| entry.status_entry().unwrap().repo_path.cmp(&path))
            {
                return Some(ix);
            }
@@ -657,14 +629,8 @@ impl GitPanel {
            } else {
                0
            } + 1;
-            if let Some(ix) =
-                binary_search(untracked_start, untracked_start + self.new_count, |ix| {
-                    self.entries[ix]
-                        .status_entry()
-                        .unwrap()
-                        .repo_path
-                        .cmp(&path)
-                })
+            if let Ok(ix) = self.entries[untracked_start..untracked_start + self.new_count]
+                .binary_search_by(|entry| entry.status_entry().unwrap().repo_path.cmp(&path))
            {
                return Some(ix);
            }
@@ -3611,6 +3577,15 @@ impl GitPanel {
                                items
                            }
                        })
+                        .when(
+                            !self.horizontal_scrollbar.show_track
+                                && self.horizontal_scrollbar.show_scrollbar,
+                            |this| {
+                                // when not showing the horizontal scrollbar track, make sure we don't
+                                // obscure the last entry
+                                this.pb(scroll_track_size)
+                            },
+                        )
                        .size_full()
                        .flex_grow()
                        .with_sizing_behavior(ListSizingBehavior::Auto)
--- a/crates/gpui/src/app/test_context.rs
+++ b/crates/gpui/src/app/test_context.rs
@@ -589,11 +589,6 @@ impl<V> Entity<V> {
        use postage::prelude::{Sink as _, Stream as _};

        let (tx, mut rx) = postage::mpsc::channel(1024);
-        let timeout_duration = if cfg!(target_os = "macos") {
-            Duration::from_millis(100)
-        } else {
-            Duration::from_secs(1)
-        };

        let mut cx = cx.app.borrow_mut();
        let subscriptions = (
@@ -615,7 +610,7 @@ impl<V> Entity<V> {
        let handle = self.downgrade();

        async move {
-            crate::util::timeout(timeout_duration, async move {
+            crate::util::timeout(Duration::from_secs(1), async move {
                loop {
                    {
                        let cx = cx.borrow();
--- a/crates/gpui/src/platform/mac/screen_capture.rs
+++ b/crates/gpui/src/platform/mac/screen_capture.rs
@@ -27,6 +27,8 @@ use objc::{
 };
 use std::{cell::RefCell, ffi::c_void, mem, ptr, rc::Rc};

+use super::NSStringExt;
+
 #[derive(Clone)]
 pub struct MacScreenCaptureSource {
    sc_display: id,
@@ -184,7 +186,10 @@ pub(crate) fn get_sources() -> oneshot::Receiver<Result<Vec<Box<dyn ScreenCaptur
                Ok(result)
            } else {
                let msg: id = msg_send![error, localizedDescription];
-                Err(anyhow!("Failed to register: {:?}", msg))
+                Err(anyhow!(
+                    "Screen share failed: {:?}",
+                    NSStringExt::to_str(&msg)
+                ))
            };
            tx.send(result).ok();
        });
--- a/crates/language_model/src/language_model.rs
+++ b/crates/language_model/src/language_model.rs
@@ -97,7 +97,10 @@ pub struct TokenUsage {

 impl TokenUsage {
    pub fn total_tokens(&self) -> u32 {
-        self.input_tokens + self.output_tokens
+        self.input_tokens
+            + self.output_tokens
+            + self.cache_read_input_tokens
+            + self.cache_creation_input_tokens
    }
 }

--- a/crates/language_model/src/model/cloud_model.rs
+++ b/crates/language_model/src/model/cloud_model.rs
@@ -142,6 +142,27 @@ impl fmt::Display for MaxMonthlySpendReachedError {
    }
 }

+#[derive(Error, Debug)]
+pub struct ModelRequestLimitReachedError {
+    pub plan: Plan,
+}
+
+impl fmt::Display for ModelRequestLimitReachedError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let message = match self.plan {
+            Plan::Free => "Model request limit reached. Upgrade to Zed Pro for more requests.",
+            Plan::ZedPro => {
+                "Model request limit reached. Upgrade to usage-based billing for more requests."
+            }
+            Plan::ZedProTrial => {
+                "Model request limit reached. Upgrade to Zed Pro for more requests."
+            }
+        };
+
+        write!(f, "{message}")
+    }
+}
+
 #[derive(Clone, Default)]
 pub struct LlmApiToken(Arc<RwLock<Option<String>>>);

--- a/crates/language_model_selector/src/language_model_selector.rs
+++ b/crates/language_model_selector/src/language_model_selector.rs
@@ -546,7 +546,6 @@ impl PickerDelegate for LanguageModelPickerDelegate {
        use feature_flags::FeatureFlagAppExt;

        let plan = proto::Plan::ZedPro;
-        let is_trial = false;

        Some(
            h_flex()
@@ -558,7 +557,6 @@ impl PickerDelegate for LanguageModelPickerDelegate {
                .justify_between()
                .when(cx.has_flag::<ZedPro>(), |this| {
                    this.child(match plan {
-                        // Already a Zed Pro subscriber
                        Plan::ZedPro => Button::new("zed-pro", "Zed Pro")
                            .icon(IconName::ZedAssistant)
                            .icon_size(IconSize::Small)
@@ -568,10 +566,9 @@ impl PickerDelegate for LanguageModelPickerDelegate {
                                window
                                    .dispatch_action(Box::new(zed_actions::OpenAccountSettings), cx)
                            }),
-                        // Free user
-                        Plan::Free => Button::new(
+                        Plan::Free | Plan::ZedProTrial => Button::new(
                            "try-pro",
-                            if is_trial {
+                            if plan == Plan::ZedProTrial {
                                "Upgrade to Pro"
                            } else {
                                "Try Pro"
--- a/crates/language_models/Cargo.toml
+++ b/crates/language_models/Cargo.toml
@@ -53,6 +53,7 @@ tokio = { workspace = true, features = ["rt", "rt-multi-thread"] }
 ui.workspace = true
 util.workspace = true
 workspace-hack.workspace = true
+zed_llm_client.workspace = true

 [dev-dependencies]
 editor = { workspace = true, features = ["test-support"] }
--- a/crates/language_models/src/provider/anthropic.rs
+++ b/crates/language_models/src/provider/anthropic.rs
@@ -705,12 +705,12 @@ pub fn map_to_language_model_completion_events(
                            update_usage(&mut state.usage, &message.usage);
                            return Some((
                                vec![
-                                    Ok(LanguageModelCompletionEvent::StartMessage {
-                                        message_id: message.id,
-                                    }),
                                    Ok(LanguageModelCompletionEvent::UsageUpdate(convert_usage(
                                        &state.usage,
                                    ))),
+                                    Ok(LanguageModelCompletionEvent::StartMessage {
+                                        message_id: message.id,
+                                    }),
                                ],
                                state,
                            ));
--- a/crates/language_models/src/provider/cloud.rs
+++ b/crates/language_models/src/provider/cloud.rs
@@ -1,9 +1,6 @@
 use anthropic::{AnthropicError, AnthropicModelMode, parse_prompt_too_long};
 use anyhow::{Result, anyhow};
-use client::{
-    Client, EXPIRED_LLM_TOKEN_HEADER_NAME, MAX_LLM_MONTHLY_SPEND_REACHED_HEADER_NAME,
-    PerformCompletionParams, UserStore, zed_urls,
-};
+use client::{Client, UserStore, zed_urls};
 use collections::BTreeMap;
 use feature_flags::{FeatureFlagAppExt, LlmClosedBeta, ZedPro};
 use futures::{
@@ -16,18 +13,20 @@ use language_model::{
    AuthenticateError, CloudModel, LanguageModel, LanguageModelCacheConfiguration, LanguageModelId,
    LanguageModelKnownError, LanguageModelName, LanguageModelProviderId, LanguageModelProviderName,
    LanguageModelProviderState, LanguageModelProviderTosView, LanguageModelRequest,
-    LanguageModelToolSchemaFormat, RateLimiter, ZED_CLOUD_PROVIDER_ID,
+    LanguageModelToolSchemaFormat, ModelRequestLimitReachedError, RateLimiter,
+    ZED_CLOUD_PROVIDER_ID,
 };
 use language_model::{
    LanguageModelAvailability, LanguageModelCompletionEvent, LanguageModelProvider, LlmApiToken,
    MaxMonthlySpendReachedError, PaymentRequiredError, RefreshLlmTokenListener,
 };
+use proto::Plan;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize, de::DeserializeOwned};
-use serde_json::value::RawValue;
 use settings::{Settings, SettingsStore};
 use smol::Timer;
 use smol::io::{AsyncReadExt, BufReader};
+use std::str::FromStr as _;
 use std::{
    sync::{Arc, LazyLock},
    time::Duration,
@@ -35,6 +34,11 @@ use std::{
 use strum::IntoEnumIterator;
 use thiserror::Error;
 use ui::{TintColor, prelude::*};
+use zed_llm_client::{
+    CURRENT_PLAN_HEADER_NAME, CompletionBody, EXPIRED_LLM_TOKEN_HEADER_NAME,
+    MAX_LLM_MONTHLY_SPEND_REACHED_HEADER_NAME, MODEL_REQUESTS_RESOURCE_HEADER_VALUE,
+    SUBSCRIPTION_LIMIT_RESOURCE_HEADER_NAME,
+};

 use crate::AllLanguageModelSettings;
 use crate::provider::anthropic::{count_anthropic_tokens, into_anthropic};
@@ -513,7 +517,7 @@ impl CloudLanguageModel {
    async fn perform_llm_completion(
        client: Arc<Client>,
        llm_api_token: LlmApiToken,
-        body: PerformCompletionParams,
+        body: CompletionBody,
    ) -> Result<Response<AsyncBody>> {
        let http_client = &client.http_client();

@@ -551,6 +555,33 @@ impl CloudLanguageModel {
                    .is_some()
            {
                return Err(anyhow!(MaxMonthlySpendReachedError));
+            } else if status == StatusCode::FORBIDDEN
+                && response
+                    .headers()
+                    .get(SUBSCRIPTION_LIMIT_RESOURCE_HEADER_NAME)
+                    .is_some()
+            {
+                if let Some(MODEL_REQUESTS_RESOURCE_HEADER_VALUE) = response
+                    .headers()
+                    .get(SUBSCRIPTION_LIMIT_RESOURCE_HEADER_NAME)
+                    .and_then(|resource| resource.to_str().ok())
+                {
+                    if let Some(plan) = response
+                        .headers()
+                        .get(CURRENT_PLAN_HEADER_NAME)
+                        .and_then(|plan| plan.to_str().ok())
+                        .and_then(|plan| zed_llm_client::Plan::from_str(plan).ok())
+                    {
+                        let plan = match plan {
+                            zed_llm_client::Plan::Free => Plan::Free,
+                            zed_llm_client::Plan::ZedPro => Plan::ZedPro,
+                            zed_llm_client::Plan::ZedProTrial => Plan::ZedProTrial,
+                        };
+                        return Err(anyhow!(ModelRequestLimitReachedError { plan }));
+                    }
+                }
+
+                return Err(anyhow!("Forbidden"));
            } else if status.as_u16() >= 500 && status.as_u16() < 600 {
                // If we encounter an error in the 500 range, retry after a delay.
                // We've seen at least these in the wild from API providers:
@@ -694,12 +725,10 @@ impl LanguageModel for CloudLanguageModel {
                    let response = Self::perform_llm_completion(
                        client.clone(),
                        llm_api_token,
-                        PerformCompletionParams {
-                            provider: client::LanguageModelProvider::Anthropic,
+                        CompletionBody {
+                            provider: zed_llm_client::LanguageModelProvider::Anthropic,
                            model: request.model.clone(),
-                            provider_request: RawValue::from_string(serde_json::to_string(
-                                &request,
-                            )?)?,
+                            provider_request: serde_json::to_value(&request)?,
                        },
                    )
                    .await
@@ -735,12 +764,10 @@ impl LanguageModel for CloudLanguageModel {
                    let response = Self::perform_llm_completion(
                        client.clone(),
                        llm_api_token,
-                        PerformCompletionParams {
-                            provider: client::LanguageModelProvider::OpenAi,
+                        CompletionBody {
+                            provider: zed_llm_client::LanguageModelProvider::OpenAi,
                            model: request.model.clone(),
-                            provider_request: RawValue::from_string(serde_json::to_string(
-                                &request,
-                            )?)?,
+                            provider_request: serde_json::to_value(&request)?,
                        },
                    )
                    .await?;
@@ -760,12 +787,10 @@ impl LanguageModel for CloudLanguageModel {
                    let response = Self::perform_llm_completion(
                        client.clone(),
                        llm_api_token,
-                        PerformCompletionParams {
-                            provider: client::LanguageModelProvider::Google,
+                        CompletionBody {
+                            provider: zed_llm_client::LanguageModelProvider::Google,
                            model: request.model.clone(),
-                            provider_request: RawValue::from_string(serde_json::to_string(
-                                &request,
-                            )?)?,
+                            provider_request: serde_json::to_value(&request)?,
                        },
                    )
                    .await?;
--- a/crates/language_tools/src/key_context_view.rs
+++ b/crates/language_tools/src/key_context_view.rs
@@ -206,12 +206,12 @@ impl Render for KeyContextView {
                    .mt_4()
                    .gap_4()
                    .child(
-                        Button::new("default", "Open Documentation")
+                        Button::new("open_documentation", "Open Documentation")
                            .style(ButtonStyle::Filled)
                            .on_click(|_, _, cx| cx.open_url("https://zed.dev/docs/key-bindings")),
                    )
                    .child(
-                        Button::new("default", "View default keymap")
+                        Button::new("view_default_keymap", "View default keymap")
                            .style(ButtonStyle::Filled)
                            .key_binding(ui::KeyBinding::for_action(
                                &zed_actions::OpenDefaultKeymap,
@@ -219,16 +219,14 @@ impl Render for KeyContextView {
                                cx
                            ))
                            .on_click(|_, window, cx| {
-                                window.dispatch_action(workspace::SplitRight.boxed_clone(), cx);
                                window.dispatch_action(zed_actions::OpenDefaultKeymap.boxed_clone(), cx);
                            }),
                    )
                    .child(
-                        Button::new("default", "Edit your keymap")
+                        Button::new("edit_your_keymap", "Edit your keymap")
                            .style(ButtonStyle::Filled)
                            .key_binding(ui::KeyBinding::for_action(&zed_actions::OpenKeymap, window, cx))
                            .on_click(|_, window, cx| {
-                                window.dispatch_action(workspace::SplitRight.boxed_clone(), cx);
                                window.dispatch_action(zed_actions::OpenKeymap.boxed_clone(), cx);
                            }),
                    ),
--- a/crates/migrator/src/migrations.rs
+++ b/crates/migrator/src/migrations.rs
@@ -39,7 +39,9 @@ pub(crate) mod m_2025_03_29 {
 }

 pub(crate) mod m_2025_04_15 {
+    mod keymap;
    mod settings;

+    pub(crate) use keymap::KEYMAP_PATTERNS;
    pub(crate) use settings::SETTINGS_PATTERNS;
 }
--- a/crates/migrator/src/migrations/m_2025_04_15/keymap.rs
+++ b/crates/migrator/src/migrations/m_2025_04_15/keymap.rs
@@ -0,0 +1,31 @@
+use collections::HashMap;
+use std::{ops::Range, sync::LazyLock};
+use tree_sitter::{Query, QueryMatch};
+
+use crate::MigrationPatterns;
+use crate::patterns::KEYMAP_ACTION_STRING_PATTERN;
+
+pub const KEYMAP_PATTERNS: MigrationPatterns =
+    &[(KEYMAP_ACTION_STRING_PATTERN, replace_string_action)];
+
+fn replace_string_action(
+    contents: &str,
+    mat: &QueryMatch,
+    query: &Query,
+) -> Option<(Range<usize>, String)> {
+    let action_name_ix = query.capture_index_for_name("action_name")?;
+    let action_name_node = mat.nodes_for_capture_index(action_name_ix).next()?;
+    let action_name_range = action_name_node.byte_range();
+    let action_name = contents.get(action_name_range.clone())?;
+
+    if let Some(new_action_name) = STRING_REPLACE.get(&action_name) {
+        return Some((action_name_range, new_action_name.to_string()));
+    }
+
+    None
+}
+
+/// "ctrl-k ctrl-1": "inline_completion::ToggleMenu" -> "edit_prediction::ToggleMenu"
+static STRING_REPLACE: LazyLock<HashMap<&str, &str>> = LazyLock::new(|| {
+    HashMap::from_iter([("outline_panel::Open", "outline_panel::OpenSelectedEntry")])
+});
--- a/crates/migrator/src/migrator.rs
+++ b/crates/migrator/src/migrator.rs
@@ -98,6 +98,10 @@ pub fn migrate_keymap(text: &str) -> Result<Option<String>> {
            migrations::m_2025_03_06::KEYMAP_PATTERNS,
            &KEYMAP_QUERY_2025_03_06,
        ),
+        (
+            migrations::m_2025_04_15::KEYMAP_PATTERNS,
+            &KEYMAP_QUERY_2025_04_15,
+        ),
    ];
    run_migrations(text, migrations)
 }
@@ -176,6 +180,10 @@ define_query!(
    KEYMAP_QUERY_2025_03_06,
    migrations::m_2025_03_06::KEYMAP_PATTERNS
 );
+define_query!(
+    KEYMAP_QUERY_2025_04_15,
+    migrations::m_2025_04_15::KEYMAP_PATTERNS
+);

 // settings
 define_query!(
--- a/crates/multi_buffer/src/anchor.rs
+++ b/crates/multi_buffer/src/anchor.rs
@@ -61,14 +61,17 @@ impl Anchor {
            return Ordering::Equal;
        }

-        let excerpt_id_cmp = self.excerpt_id.cmp(&other.excerpt_id, snapshot);
+        let self_excerpt_id = snapshot.latest_excerpt_id(self.excerpt_id);
+        let other_excerpt_id = snapshot.latest_excerpt_id(other.excerpt_id);
+
+        let excerpt_id_cmp = self_excerpt_id.cmp(&other_excerpt_id, snapshot);
        if excerpt_id_cmp.is_ne() {
            return excerpt_id_cmp;
        }
-        if self.excerpt_id == ExcerptId::min() || self.excerpt_id == ExcerptId::max() {
+        if self_excerpt_id == ExcerptId::min() || self_excerpt_id == ExcerptId::max() {
            return Ordering::Equal;
        }
-        if let Some(excerpt) = snapshot.excerpt(self.excerpt_id) {
+        if let Some(excerpt) = snapshot.excerpt(self_excerpt_id) {
            let text_cmp = self.text_anchor.cmp(&other.text_anchor, &excerpt.buffer);
            if text_cmp.is_ne() {
                return text_cmp;
--- a/crates/multi_buffer/src/multi_buffer.rs
+++ b/crates/multi_buffer/src/multi_buffer.rs
@@ -5170,6 +5170,7 @@ impl MultiBufferSnapshot {
        excerpt_id: ExcerptId,
        text_anchor: text::Anchor,
    ) -> Option<Anchor> {
+        let excerpt_id = self.latest_excerpt_id(excerpt_id);
        let locator = self.excerpt_locator_for_id(excerpt_id);
        let mut cursor = self.excerpts.cursor::<Option<&Locator>>(&());
        cursor.seek(locator, Bias::Left, &());
@@ -6041,7 +6042,7 @@ impl MultiBufferSnapshot {
                    return &entry.locator;
                }
            }
-            panic!("invalid excerpt id {:?}", id)
+            panic!("invalid excerpt id {id:?}")
        }
    }

--- a/crates/multi_buffer/src/multi_buffer_tests.rs
+++ b/crates/multi_buffer/src/multi_buffer_tests.rs
@@ -746,19 +746,20 @@ fn test_expand_excerpts(cx: &mut App) {
    drop(snapshot);

    multibuffer.update(cx, |multibuffer, cx| {
+        let line_zero = multibuffer.snapshot(cx).anchor_before(Point::new(0, 0));
        multibuffer.expand_excerpts(
            multibuffer.excerpt_ids(),
            1,
            ExpandExcerptDirection::UpAndDown,
            cx,
-        )
+        );
+        let snapshot = multibuffer.snapshot(cx);
+        let line_two = snapshot.anchor_before(Point::new(2, 0));
+        assert_eq!(line_two.cmp(&line_zero, &snapshot), cmp::Ordering::Greater);
    });

    let snapshot = multibuffer.read(cx).snapshot(cx);

-    // Expanding context lines causes the line containing 'fff' to appear in two different excerpts.
-    // We don't attempt to merge them, because removing the excerpt could create inconsistency with other layers
-    // that are tracking excerpt ids.
    assert_eq!(
        snapshot.text(),
        concat!(
--- a/crates/outline_panel/src/outline_panel.rs
+++ b/crates/outline_panel/src/outline_panel.rs
@@ -70,7 +70,7 @@ actions!(
        ExpandAllEntries,
        ExpandSelectedEntry,
        FoldDirectory,
-        Open,
+        OpenSelectedEntry,
        RevealInFileManager,
        SelectParent,
        ToggleActiveEditorPin,
@@ -922,7 +922,12 @@ impl OutlinePanel {
        self.update_cached_entries(None, window, cx);
    }

-    fn open(&mut self, _: &Open, window: &mut Window, cx: &mut Context<Self>) {
+    fn open_selected_entry(
+        &mut self,
+        _: &OpenSelectedEntry,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
        if self.filter_editor.focus_handle(cx).is_focused(window) {
            cx.propagate()
        } else if let Some(selected_entry) = self.selected_entry().cloned() {
@@ -4906,7 +4911,7 @@ impl Render for OutlinePanel {
                }
            }))
            .key_context(self.dispatch_context(window, cx))
-            .on_action(cx.listener(Self::open))
+            .on_action(cx.listener(Self::open_selected_entry))
            .on_action(cx.listener(Self::cancel))
            .on_action(cx.listener(Self::select_next))
            .on_action(cx.listener(Self::select_previous))
@@ -5677,7 +5682,7 @@ mod tests {
        });

        outline_panel.update_in(cx, |outline_panel, window, cx| {
-            outline_panel.open(&Open, window, cx);
+            outline_panel.open_selected_entry(&OpenSelectedEntry, window, cx);
        });
        outline_panel.update(cx, |_outline_panel, cx| {
            assert_eq!(
@@ -5852,7 +5857,7 @@ mod tests {

        outline_panel.update_in(cx, |outline_panel, window, cx| {
            outline_panel.select_previous(&SelectPrevious, window, cx);
-            outline_panel.open(&Open, window, cx);
+            outline_panel.open_selected_entry(&OpenSelectedEntry, window, cx);
        });
        cx.executor()
            .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100));
@@ -5876,7 +5881,7 @@ mod tests {

        outline_panel.update_in(cx, |outline_panel, window, cx| {
            outline_panel.select_next(&SelectNext, window, cx);
-            outline_panel.open(&Open, window, cx);
+            outline_panel.open_selected_entry(&OpenSelectedEntry, window, cx);
        });
        cx.executor()
            .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100));
@@ -5897,7 +5902,7 @@ mod tests {
        });

        outline_panel.update_in(cx, |outline_panel, window, cx| {
-            outline_panel.open(&Open, window, cx);
+            outline_panel.open_selected_entry(&OpenSelectedEntry, window, cx);
        });
        cx.executor()
            .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100));
--- a/crates/project/src/debugger/breakpoint_store.rs
+++ b/crates/project/src/debugger/breakpoint_store.rs
@@ -18,7 +18,7 @@ use text::{Point, PointUtf16};
 use crate::{Project, ProjectPath, buffer_store::BufferStore, worktree_store::WorktreeStore};

 mod breakpoints_in_file {
-    use language::BufferEvent;
+    use language::{BufferEvent, DiskState};

    use super::*;

@@ -32,8 +32,9 @@ mod breakpoints_in_file {

    impl BreakpointsInFile {
        pub(super) fn new(buffer: Entity<Buffer>, cx: &mut Context<BreakpointStore>) -> Self {
-            let subscription =
-                Arc::from(cx.subscribe(&buffer, |_, buffer, event, cx| match event {
+            let subscription = Arc::from(cx.subscribe(
+                &buffer,
+                |breakpoint_store, buffer, event, cx| match event {
                    BufferEvent::Saved => {
                        if let Some(abs_path) = BreakpointStore::abs_path_from_buffer(&buffer, cx) {
                            cx.emit(BreakpointStoreEvent::BreakpointsUpdated(
@@ -42,8 +43,44 @@ mod breakpoints_in_file {
                            ));
                        }
                    }
+                    BufferEvent::FileHandleChanged => {
+                        let entity_id = buffer.entity_id();
+
+                        if buffer.read(cx).file().is_none_or(|f| f.disk_state() == DiskState::Deleted) {
+                            breakpoint_store.breakpoints.retain(|_, breakpoints_in_file| {
+                                breakpoints_in_file.buffer.entity_id() != entity_id
+                            });
+
+                            cx.notify();
+                            return;
+                        }
+
+                        if let Some(abs_path) = BreakpointStore::abs_path_from_buffer(&buffer, cx) {
+                            if breakpoint_store.breakpoints.contains_key(&abs_path) {
+                                return;
+                            }
+
+                            if let Some(old_path) = breakpoint_store
+                                .breakpoints
+                                .iter()
+                                .find(|(_, in_file)| in_file.buffer.entity_id() == entity_id)
+                                .map(|values| values.0)
+                                .cloned()
+                            {
+                                let Some(breakpoints_in_file) =
+                                    breakpoint_store.breakpoints.remove(&old_path) else {
+                                        log::error!("Couldn't get breakpoints in file from old path during buffer rename handling");
+                                        return;
+                                    };
+
+                                breakpoint_store.breakpoints.insert(abs_path, breakpoints_in_file);
+                                cx.notify();
+                            }
+                        }
+                    }
                    _ => {}
-                }));
+                },
+            ));

            BreakpointsInFile {
                buffer,
--- a/crates/project/src/debugger/dap_store.rs
+++ b/crates/project/src/debugger/dap_store.rs
@@ -21,7 +21,10 @@ use futures::{
    channel::{mpsc, oneshot},
    future::{Shared, join_all},
 };
-use gpui::{App, AppContext, AsyncApp, Context, Entity, EventEmitter, SharedString, Task};
+use gpui::{
+    App, AppContext, AsyncApp, BackgroundExecutor, Context, Entity, EventEmitter, SharedString,
+    Task,
+};
 use http_client::HttpClient;
 use language::{BinaryStatus, LanguageRegistry, LanguageToolchainStore};
 use lsp::LanguageServerName;
@@ -90,6 +93,17 @@ impl LocalDapStore {
    fn next_session_id(&self) -> SessionId {
        SessionId(self.next_session_id.fetch_add(1, SeqCst))
    }
+    pub(crate) fn locate_binary(
+        &self,
+        mut definition: DebugTaskDefinition,
+        executor: BackgroundExecutor,
+    ) -> Task<DebugTaskDefinition> {
+        let locator_store = self.locator_store.clone();
+        executor.spawn(async move {
+            let _ = locator_store.resolve_debug_config(&mut definition).await;
+            definition
+        })
+    }
 }

 pub struct RemoteDapStore {
@@ -335,7 +349,7 @@ impl DapStore {
    pub fn new_session(
        &mut self,
        binary: DebugAdapterBinary,
-        mut config: DebugTaskDefinition,
+        config: DebugTaskDefinition,
        parent_session: Option<Entity<Session>>,
        cx: &mut Context<Self>,
    ) -> (SessionId, Task<Result<Entity<Session>>>) {
@@ -352,22 +366,10 @@ impl DapStore {
        }

        let (initialized_tx, initialized_rx) = oneshot::channel();
-        let locator_store = local_store.locator_store.clone();

        let start_debugging_tx = local_store.start_debugging_tx.clone();

        let task = cx.spawn(async move |this, cx| {
-            if config.locator.is_some() {
-                config = cx
-                    .background_spawn(async move {
-                        locator_store
-                            .resolve_debug_config(&mut config)
-                            .await
-                            .map(|_| config)
-                    })
-                    .await?;
-            }
-
            let start_client_task = this.update(cx, |this, cx| {
                Session::local(
                    this.breakpoint_store.clone(),
@@ -790,10 +792,48 @@ fn create_new_session(
        this.update(cx, |_, cx| {
            cx.subscribe(
                &session,
-                move |this: &mut DapStore, _, event: &SessionStateEvent, cx| match event {
+                move |this: &mut DapStore, session, event: &SessionStateEvent, cx| match event {
                    SessionStateEvent::Shutdown => {
                        this.shutdown_session(session_id, cx).detach_and_log_err(cx);
                    }
+                    SessionStateEvent::Restart => {
+                        let Some((config, binary)) = session.read_with(cx, |session, _| {
+                            session
+                                .configuration()
+                                .map(|config| (config, session.binary().clone()))
+                        }) else {
+                            log::error!("Failed to get debug config from session");
+                            return;
+                        };
+
+                        let mut curr_session = session;
+                        while let Some(parent_id) = curr_session.read(cx).parent_id() {
+                            if let Some(parent_session) = this.sessions.get(&parent_id).cloned() {
+                                curr_session = parent_session;
+                            } else {
+                                log::error!("Failed to get parent session from parent session id");
+                                break;
+                            }
+                        }
+
+                        let session_id = curr_session.read(cx).session_id();
+
+                        let task = curr_session.update(cx, |session, cx| session.shutdown(cx));
+
+                        cx.spawn(async move |this, cx| {
+                            task.await;
+
+                            this.update(cx, |this, cx| {
+                                this.sessions.remove(&session_id);
+                                this.new_session(binary, config, None, cx)
+                            })?
+                            .1
+                            .await?;
+
+                            anyhow::Ok(())
+                        })
+                        .detach_and_log_err(cx);
+                    }
                },
            )
            .detach();
--- a/crates/project/src/debugger/locator_store/cargo.rs
+++ b/crates/project/src/debugger/locator_store/cargo.rs
@@ -1,13 +1,12 @@
 use super::DapLocator;
 use anyhow::{Result, anyhow};
 use async_trait::async_trait;
-use serde_json::{Value, json};
+use serde_json::Value;
 use smol::{
    io::AsyncReadExt,
    process::{Command, Stdio},
 };
 use task::DebugTaskDefinition;
-use util::maybe;

 pub(super) struct CargoLocator;

@@ -109,43 +108,13 @@ impl DapLocator for CargoLocator {
                None
            }
        };
+
        let Some(executable) = executable.or_else(|| executables.first().cloned()) else {
            return Err(anyhow!("Couldn't get executable in cargo locator"));
        };

        launch_config.program = executable;

-        if debug_config.adapter == "LLDB" && debug_config.initialize_args.is_none() {
-            // Find Rust pretty-printers in current toolchain's sysroot
-            let cwd = launch_config.cwd.clone();
-            debug_config.initialize_args = maybe!(async move {
-                let cwd = cwd?;
-
-                let output = Command::new("rustc")
-                    .arg("--print")
-                    .arg("sysroot")
-                    .current_dir(cwd)
-                    .output()
-                    .await
-                    .ok()?;
-
-                if !output.status.success() {
-                    return None;
-                }
-
-                let sysroot_path = String::from_utf8(output.stdout).ok()?;
-                let sysroot_path = sysroot_path.trim_end();
-                let first_command = format!(
-                    r#"command script import "{sysroot_path}/lib/rustlib/etc/lldb_lookup.py"#
-                );
-                let second_command =
-                    format!(r#"command source -s 0 '{sysroot_path}/lib/rustlib/etc/lldb_commands"#);
-
-                Some(json!({"initCommands": [first_command, second_command]}))
-            })
-            .await;
-        }
-
        launch_config.args.clear();
        if let Some(test_name) = test_name {
            launch_config.args.push(test_name);
--- a/crates/project/src/debugger/session.rs
+++ b/crates/project/src/debugger/session.rs
@@ -397,6 +397,7 @@ impl LocalMode {
            self.definition.initialize_args.clone().unwrap_or(json!({})),
            &mut raw.configuration,
        );
+
        // Of relevance: https://github.com/microsoft/vscode/issues/4902#issuecomment-368583522
        let launch = match raw.request {
            dap::StartDebuggingRequestArgumentsRequest::Launch => self.request(
@@ -684,8 +685,9 @@ pub enum SessionEvent {
    Threads,
 }

-pub(crate) enum SessionStateEvent {
+pub(super) enum SessionStateEvent {
    Shutdown,
+    Restart,
 }

 impl EventEmitter<SessionEvent> for Session {}
@@ -1362,6 +1364,18 @@ impl Session {
        &self.loaded_sources
    }

+    fn fallback_to_manual_restart(
+        &mut self,
+        res: Result<()>,
+        cx: &mut Context<Self>,
+    ) -> Option<()> {
+        if res.log_err().is_none() {
+            cx.emit(SessionStateEvent::Restart);
+            return None;
+        }
+        Some(())
+    }
+
    fn empty_response(&mut self, res: Result<()>, _cx: &mut Context<Self>) -> Option<()> {
        res.log_err()?;
        Some(())
@@ -1421,26 +1435,17 @@ impl Session {
    }

    pub fn restart(&mut self, args: Option<Value>, cx: &mut Context<Self>) {
-        if self.capabilities.supports_restart_request.unwrap_or(false) {
+        if self.capabilities.supports_restart_request.unwrap_or(false) && !self.is_terminated() {
            self.request(
                RestartCommand {
                    raw: args.unwrap_or(Value::Null),
                },
-                Self::empty_response,
+                Self::fallback_to_manual_restart,
                cx,
            )
            .detach();
        } else {
-            self.request(
-                DisconnectCommand {
-                    restart: Some(false),
-                    terminate_debuggee: Some(true),
-                    suspend_debuggee: Some(false),
-                },
-                Self::empty_response,
-                cx,
-            )
-            .detach();
+            cx.emit(SessionStateEvent::Restart);
        }
    }

@@ -1475,8 +1480,14 @@ impl Session {

        cx.emit(SessionStateEvent::Shutdown);

+        let debug_client = self.adapter_client();
+
        cx.background_spawn(async move {
            let _ = task.await;
+
+            if let Some(client) = debug_client {
+                client.shutdown().await.log_err();
+            }
        })
    }

--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -1482,6 +1482,18 @@ impl Project {
                    .update(cx, |dap_store, cx| dap_store.delegate(&worktree, cx))
            })?;

+            let task = this.update(cx, |project, cx| {
+                project.dap_store.read(cx).as_local().and_then(|local| {
+                    config.locator.is_some().then(|| {
+                        local.locate_binary(config.clone(), cx.background_executor().clone())
+                    })
+                })
+            })?;
+            let config = if let Some(task) = task {
+                task.await
+            } else {
+                config
+            };
            let binary = adapter
                .get_binary(&delegate, &config, user_installed_path, cx)
                .await?;
@@ -3082,6 +3094,9 @@ impl Project {
            .map(|lister| lister.term())
    }

+    pub fn toolchain_store(&self) -> Option<Entity<ToolchainStore>> {
+        self.toolchain_store.clone()
+    }
    pub fn activate_toolchain(
        &self,
        path: ProjectPath,
--- a/crates/project/src/project_tests.rs
+++ b/crates/project/src/project_tests.rs
@@ -8273,17 +8273,34 @@ async fn test_git_worktrees_and_submodules(cx: &mut gpui::TestAppContext) {
        json!({
            ".git": {
                "worktrees": {
-                    "some-worktree": {}
+                    "some-worktree": {
+                        "commondir": "../..\n"
+                    }
                },
+                "modules": {
+                    "subdir": {
+                        "some-submodule": {
+                            // For is_git_dir
+                            "HEAD": "",
+                            "config": "",
+                        }
+                    }
+                }
            },
            "src": {
                "a.txt": "A",
            },
            "some-worktree": {
-                ".git": "gitdir: ../.git/worktrees/some-worktree",
+                ".git": "gitdir: ../.git/worktrees/some-worktree\n",
                "src": {
                    "b.txt": "B",
                }
+            },
+            "subdir": {
+                "some-submodule": {
+                    ".git": "gitdir: ../../.git/modules/subdir/some-submodule\n",
+                    "c.txt": "C",
+                }
            }
        }),
    )
@@ -8315,9 +8332,11 @@ async fn test_git_worktrees_and_submodules(cx: &mut gpui::TestAppContext) {
        [
            Path::new(path!("/project")).into(),
            Path::new(path!("/project/some-worktree")).into(),
+            Path::new(path!("/project/subdir/some-submodule")).into(),
        ]
    );

+    // Generate a git-related event for the worktree and check that it's refreshed.
    fs.with_git_state(
        path!("/project/some-worktree/.git").as_ref(),
        true,
@@ -8359,6 +8378,45 @@ async fn test_git_worktrees_and_submodules(cx: &mut gpui::TestAppContext) {
            StatusCode::Modified.worktree(),
        );
    });
+
+    // The same for the submodule.
+    fs.with_git_state(
+        path!("/project/subdir/some-submodule/.git").as_ref(),
+        true,
+        |state| {
+            state.head_contents.insert("c.txt".into(), "c".to_owned());
+            state.index_contents.insert("c.txt".into(), "c".to_owned());
+        },
+    )
+    .unwrap();
+    cx.run_until_parked();
+
+    let buffer = project
+        .update(cx, |project, cx| {
+            project.open_local_buffer(path!("/project/subdir/some-submodule/c.txt"), cx)
+        })
+        .await
+        .unwrap();
+    let (submodule_repo, barrier) = project.update(cx, |project, cx| {
+        let (repo, _) = project
+            .git_store()
+            .read(cx)
+            .repository_and_path_for_buffer_id(buffer.read(cx).remote_id(), cx)
+            .unwrap();
+        pretty_assertions::assert_eq!(
+            repo.read(cx).work_directory_abs_path,
+            Path::new(path!("/project/subdir/some-submodule")).into(),
+        );
+        let barrier = repo.update(cx, |repo, _| repo.barrier());
+        (repo.clone(), barrier)
+    });
+    barrier.await.unwrap();
+    submodule_repo.update(cx, |repo, _| {
+        pretty_assertions::assert_eq!(
+            repo.status_for_path(&"c.txt".into()).unwrap().status,
+            StatusCode::Modified.worktree(),
+        );
+    });
 }

 #[gpui::test]
--- a/crates/project/src/toolchain_store.rs
+++ b/crates/project/src/toolchain_store.rs
@@ -55,6 +55,7 @@ impl ToolchainStore {
        });
        Self(ToolchainStoreInner::Local(entity, subscription))
    }
+
    pub(super) fn remote(project_id: u64, client: AnyProtoClient, cx: &mut App) -> Self {
        Self(ToolchainStoreInner::Remote(
            cx.new(|_| RemoteToolchainStore { client, project_id }),
@@ -285,7 +286,7 @@ struct LocalStore(WeakEntity<LocalToolchainStore>);
 struct RemoteStore(WeakEntity<RemoteToolchainStore>);

 #[derive(Clone)]
-pub(crate) enum ToolchainStoreEvent {
+pub enum ToolchainStoreEvent {
    ToolchainActivated,
 }

--- a/crates/proto/proto/app.proto
+++ b/crates/proto/proto/app.proto
@@ -18,6 +18,7 @@ message GetPrivateUserInfoResponse {
 enum Plan {
    Free = 0;
    ZedPro = 1;
+    ZedProTrial = 2;
 }

 message UpdateUserPlan {
--- a/crates/remote_server/Cargo.toml
+++ b/crates/remote_server/Cargo.toml
@@ -23,6 +23,7 @@ test-support = ["fs/test-support"]

 [dependencies]
 anyhow.workspace = true
+askpass.workspace = true
 async-watch.workspace = true
 backtrace = "0.3"
 chrono.workspace = true
--- a/crates/remote_server/src/main.rs
+++ b/crates/remote_server/src/main.rs
@@ -8,6 +8,10 @@ use std::path::PathBuf;
 struct Cli {
    #[command(subcommand)]
    command: Option<Commands>,
+    /// Used for SSH/Git password authentication, to remove the need for netcat as a dependency,
+    /// by having Zed act like netcat communicating over a Unix socket.
+    #[arg(long, hide = true)]
+    askpass: Option<String>,
 }

 #[derive(Subcommand)]
@@ -46,6 +50,11 @@ fn main() {

    let cli = Cli::parse();

+    if let Some(socket_path) = &cli.askpass {
+        askpass::main(socket_path);
+        return;
+    }
+
    let result = match cli.command {
        Some(Commands::Run {
            log_file,
--- a/crates/rpc/src/llm.rs
+++ b/crates/rpc/src/llm.rs
@@ -1,35 +0,0 @@
-use serde::{Deserialize, Serialize};
-use strum::{Display, EnumIter, EnumString};
-
-pub const EXPIRED_LLM_TOKEN_HEADER_NAME: &str = "x-zed-expired-token";
-
-pub const MAX_LLM_MONTHLY_SPEND_REACHED_HEADER_NAME: &str = "x-zed-llm-max-monthly-spend-reached";
-
-#[derive(
-    Debug, PartialEq, Eq, Hash, Clone, Copy, Serialize, Deserialize, EnumString, EnumIter, Display,
-)]
-#[serde(rename_all = "snake_case")]
-#[strum(serialize_all = "snake_case")]
-pub enum LanguageModelProvider {
-    Anthropic,
-    OpenAi,
-    Google,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct LanguageModel {
-    pub provider: LanguageModelProvider,
-    pub name: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct ListModelsResponse {
-    pub models: Vec<LanguageModel>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct PerformCompletionParams {
-    pub provider: LanguageModelProvider,
-    pub model: String,
-    pub provider_request: Box<serde_json::value::RawValue>,
-}
--- a/crates/rpc/src/rpc.rs
+++ b/crates/rpc/src/rpc.rs
@@ -1,14 +1,12 @@
 pub mod auth;
 mod conn;
 mod extension;
-mod llm;
 mod message_stream;
 mod notification;
 mod peer;

 pub use conn::Connection;
 pub use extension::*;
-pub use llm::*;
 pub use notification::*;
 pub use peer::*;
 pub use proto;
--- a/crates/task/src/debug_format.rs
+++ b/crates/task/src/debug_format.rs
@@ -98,62 +98,6 @@ impl DebugRequestDisposition {
        }
    }
 }
-/// Represents the configuration for the debug adapter
-#[derive(PartialEq, Eq, Clone, Debug)]
-pub struct DebugAdapterConfig {
-    /// Name of the debug task
-    pub label: String,
-    /// The type of adapter you want to use
-    pub adapter: String,
-    /// The type of request that should be called on the debug adapter
-    pub request: DebugRequestDisposition,
-    /// Additional initialization arguments to be sent on DAP initialization
-    pub initialize_args: Option<serde_json::Value>,
-    /// Optional TCP connection information
-    ///
-    /// If provided, this will be used to connect to the debug adapter instead of
-    /// spawning a new process. This is useful for connecting to a debug adapter
-    /// that is already running or is started by another process.
-    pub tcp_connection: Option<TCPHost>,
-    /// What Locator to use to configure the debug task
-    pub locator: Option<String>,
-    /// Whether to tell the debug adapter to stop on entry
-    pub stop_on_entry: Option<bool>,
-}
-
-impl From<DebugTaskDefinition> for DebugAdapterConfig {
-    fn from(def: DebugTaskDefinition) -> Self {
-        Self {
-            label: def.label,
-            adapter: def.adapter,
-            request: DebugRequestDisposition::UserConfigured(def.request),
-            initialize_args: def.initialize_args,
-            tcp_connection: def.tcp_connection,
-            locator: def.locator,
-            stop_on_entry: def.stop_on_entry,
-        }
-    }
-}
-
-impl TryFrom<DebugAdapterConfig> for DebugTaskDefinition {
-    type Error = ();
-    fn try_from(def: DebugAdapterConfig) -> Result<Self, Self::Error> {
-        let request = match def.request {
-            DebugRequestDisposition::UserConfigured(debug_request_type) => debug_request_type,
-            DebugRequestDisposition::ReverseRequest(_) => return Err(()),
-        };
-
-        Ok(Self {
-            label: def.label,
-            adapter: def.adapter,
-            request,
-            initialize_args: def.initialize_args,
-            tcp_connection: def.tcp_connection,
-            locator: def.locator,
-            stop_on_entry: def.stop_on_entry,
-        })
-    }
-}

 impl TryFrom<TaskTemplate> for DebugTaskDefinition {
    type Error = ();
--- a/crates/task/src/lib.rs
+++ b/crates/task/src/lib.rs
@@ -16,8 +16,8 @@ use std::path::PathBuf;
 use std::str::FromStr;

 pub use debug_format::{
-    AttachConfig, DebugAdapterConfig, DebugConnectionType, DebugRequestDisposition,
-    DebugRequestType, DebugTaskDefinition, DebugTaskFile, LaunchConfig, TCPHost,
+    AttachConfig, DebugConnectionType, DebugRequestDisposition, DebugRequestType,
+    DebugTaskDefinition, DebugTaskFile, LaunchConfig, TCPHost,
 };
 pub use task_template::{
    DebugArgs, DebugArgsRequest, HideStrategy, RevealStrategy, TaskModal, TaskTemplate,
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -36,7 +36,7 @@ use ui::{
    IconWithIndicator, Indicator, PopoverMenu, Tooltip, h_flex, prelude::*,
 };
 use util::ResultExt;
-use workspace::{BottomDockLayout, Workspace, notifications::NotifyResultExt};
+use workspace::{Workspace, notifications::NotifyResultExt};
 use zed_actions::{OpenBrowser, OpenRecent, OpenRemote};

 pub use onboarding_banner::restore_banner;
@@ -210,7 +210,6 @@ impl Render for TitleBar {
                            .pr_1()
                            .on_mouse_down(MouseButton::Left, |_, _, cx| cx.stop_propagation())
                            .children(self.render_call_controls(window, cx))
-                            .child(self.render_bottom_dock_layout_menu(cx))
                            .map(|el| {
                                let status = self.client.status();
                                let status = &*status.borrow();
@@ -302,7 +301,7 @@ impl TitleBar {
                cx.notify()
            }),
        );
-        subscriptions.push(cx.subscribe(&project, |_, _, _, cx| cx.notify()));
+        subscriptions.push(cx.subscribe(&project, |_, _, _: &project::Event, cx| cx.notify()));
        subscriptions.push(cx.observe(&active_call, |this, _, cx| this.active_call_changed(cx)));
        subscriptions.push(cx.observe_window_activation(window, Self::window_activation_changed));
        subscriptions.push(cx.observe(&user_store, |_, _, cx| cx.notify()));
@@ -623,101 +622,6 @@ impl TitleBar {
        }
    }

-    pub fn render_bottom_dock_layout_menu(&self, cx: &mut Context<Self>) -> impl IntoElement {
-        let workspace = self.workspace.upgrade().unwrap();
-        let current_layout = workspace.update(cx, |workspace, _cx| workspace.bottom_dock_layout());
-
-        PopoverMenu::new("layout-menu")
-            .trigger(
-                IconButton::new("toggle_layout", IconName::Layout)
-                    .icon_size(IconSize::Small)
-                    .tooltip(Tooltip::text("Toggle Layout Menu")),
-            )
-            .anchor(gpui::Corner::TopRight)
-            .menu(move |window, cx| {
-                ContextMenu::build(window, cx, {
-                    let workspace = workspace.clone();
-                    move |menu, _, _| {
-                        menu.label("Bottom Dock")
-                            .separator()
-                            .toggleable_entry(
-                                "Contained",
-                                current_layout == BottomDockLayout::Contained,
-                                ui::IconPosition::End,
-                                None,
-                                {
-                                    let workspace = workspace.clone();
-                                    move |window, cx| {
-                                        workspace.update(cx, |workspace, cx| {
-                                            workspace.set_bottom_dock_layout(
-                                                BottomDockLayout::Contained,
-                                                window,
-                                                cx,
-                                            );
-                                        });
-                                    }
-                                },
-                            )
-                            .toggleable_entry(
-                                "Full",
-                                current_layout == BottomDockLayout::Full,
-                                ui::IconPosition::End,
-                                None,
-                                {
-                                    let workspace = workspace.clone();
-                                    move |window, cx| {
-                                        workspace.update(cx, |workspace, cx| {
-                                            workspace.set_bottom_dock_layout(
-                                                BottomDockLayout::Full,
-                                                window,
-                                                cx,
-                                            );
-                                        });
-                                    }
-                                },
-                            )
-                            .toggleable_entry(
-                                "Left Aligned",
-                                current_layout == BottomDockLayout::LeftAligned,
-                                ui::IconPosition::End,
-                                None,
-                                {
-                                    let workspace = workspace.clone();
-                                    move |window, cx| {
-                                        workspace.update(cx, |workspace, cx| {
-                                            workspace.set_bottom_dock_layout(
-                                                BottomDockLayout::LeftAligned,
-                                                window,
-                                                cx,
-                                            );
-                                        });
-                                    }
-                                },
-                            )
-                            .toggleable_entry(
-                                "Right Aligned",
-                                current_layout == BottomDockLayout::RightAligned,
-                                ui::IconPosition::End,
-                                None,
-                                {
-                                    let workspace = workspace.clone();
-                                    move |window, cx| {
-                                        workspace.update(cx, |workspace, cx| {
-                                            workspace.set_bottom_dock_layout(
-                                                BottomDockLayout::RightAligned,
-                                                window,
-                                                cx,
-                                            );
-                                        });
-                                    }
-                                },
-                            )
-                    }
-                })
-                .into()
-            })
-    }
-
    pub fn render_sign_in_button(&mut self, _: &mut Context<Self>) -> Button {
        let client = self.client.clone();
        Button::new("sign_in", "Sign in")
@@ -751,6 +655,7 @@ impl TitleBar {
                                        None => "",
                                        Some(proto::Plan::Free) => "Free",
                                        Some(proto::Plan::ZedPro) => "Pro",
+                                        Some(proto::Plan::ZedProTrial) => "Pro (Trial)",
                                    }
                                ),
                                zed_actions::OpenAccountSettings.boxed_clone(),
--- a/crates/toolchain_selector/src/active_toolchain.rs
+++ b/crates/toolchain_selector/src/active_toolchain.rs
@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use std::{path::Path, sync::Arc};

 use editor::Editor;
 use gpui::{
@@ -6,7 +6,7 @@ use gpui::{
    WeakEntity, Window, div,
 };
 use language::{Buffer, BufferEvent, LanguageName, Toolchain};
-use project::{Project, ProjectPath, WorktreeId};
+use project::{Project, ProjectPath, WorktreeId, toolchain_store::ToolchainStoreEvent};
 use ui::{Button, ButtonCommon, Clickable, FluentBuilder, LabelSize, SharedString, Tooltip};
 use workspace::{StatusItemView, Workspace, item::ItemHandle};

@@ -22,6 +22,28 @@ pub struct ActiveToolchain {

 impl ActiveToolchain {
    pub fn new(workspace: &Workspace, window: &mut Window, cx: &mut Context<Self>) -> Self {
+        if let Some(store) = workspace.project().read(cx).toolchain_store() {
+            cx.subscribe_in(
+                &store,
+                window,
+                |this, _, _: &ToolchainStoreEvent, window, cx| {
+                    let editor = this
+                        .workspace
+                        .update(cx, |workspace, cx| {
+                            workspace
+                                .active_item(cx)
+                                .and_then(|item| item.downcast::<Editor>())
+                        })
+                        .ok()
+                        .flatten();
+                    if let Some(editor) = editor {
+                        this.active_toolchain.take();
+                        this.update_lister(editor, window, cx);
+                    }
+                },
+            )
+            .detach();
+        }
        Self {
            active_toolchain: None,
            active_buffer: None,
@@ -57,12 +79,19 @@ impl ActiveToolchain {
                this.term = term;
                cx.notify();
            });
-            let worktree_id = active_file
-                .update(cx, |this, cx| Some(this.file()?.worktree_id(cx)))
+            let (worktree_id, path) = active_file
+                .update(cx, |this, cx| {
+                    this.file().and_then(|file| {
+                        Some((
+                            file.worktree_id(cx),
+                            Arc::<Path>::from(file.path().parent()?),
+                        ))
+                    })
+                })
                .ok()
                .flatten()?;
            let toolchain =
-                Self::active_toolchain(workspace, worktree_id, language_name, cx).await?;
+                Self::active_toolchain(workspace, worktree_id, path, language_name, cx).await?;
            let _ = this.update(cx, |this, cx| {
                this.active_toolchain = Some(toolchain);

@@ -101,6 +130,7 @@ impl ActiveToolchain {
    fn active_toolchain(
        workspace: WeakEntity<Workspace>,
        worktree_id: WorktreeId,
+        relative_path: Arc<Path>,
        language_name: LanguageName,
        cx: &mut AsyncWindowContext,
    ) -> Task<Option<Toolchain>> {
@@ -114,7 +144,7 @@ impl ActiveToolchain {
                    this.project().read(cx).active_toolchain(
                        ProjectPath {
                            worktree_id,
-                            path: Arc::from("".as_ref()),
+                            path: relative_path.clone(),
                        },
                        language_name.clone(),
                        cx,
@@ -133,7 +163,7 @@ impl ActiveToolchain {
                        project.read(cx).available_toolchains(
                            ProjectPath {
                                worktree_id,
-                                path: Arc::from("".as_ref()),
+                                path: relative_path.clone(),
                            },
                            language_name,
                            cx,
@@ -144,7 +174,12 @@ impl ActiveToolchain {
                if let Some(toolchain) = toolchains.toolchains.first() {
                    // Since we don't have a selected toolchain, pick one for user here.
                    workspace::WORKSPACE_DB
-                        .set_toolchain(workspace_id, worktree_id, "".to_owned(), toolchain.clone())
+                        .set_toolchain(
+                            workspace_id,
+                            worktree_id,
+                            relative_path.to_string_lossy().into_owned(),
+                            toolchain.clone(),
+                        )
                        .await
                        .ok()?;
                    project
@@ -152,7 +187,7 @@ impl ActiveToolchain {
                            this.activate_toolchain(
                                ProjectPath {
                                    worktree_id,
-                                    path: Arc::from("".as_ref()),
+                                    path: relative_path,
                                },
                                toolchain.clone(),
                                cx,
--- a/Show More
+++ b/Show More