From 8ce894b909ec3cbbb84e1bc8eedc542a5f975c61 Mon Sep 17 00:00:00 2001
From: Koya Masuda <71430401+koxya@users.noreply.github.com>
Date: Mon, 18 May 2026 22:13:41 +0900
Subject: [PATCH 001/105] git_ui: Count commit title length by characters
 instead of bytes (#57025)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# What

- Replace `title.len()` with `title.chars().count()` in the commit title
length check, so the limit is measured in Unicode characters instead of
UTF-8 bytes.
- Applied in two places that share the same logic:
  - `crates/git_ui/src/git_panel.rs` — Git panel's inline warning
  - `crates/git_ui/src/commit_modal.rs` — commit modal's inline warning

# Why

The commit title length check used str::len(), which returns UTF-8 byte
length rather than character count. As a result, titles containing
multi-byte characters (Japanese, Chinese, emoji, etc.) triggered the
warning far below the configured commit_title_max_length — around 24
characters instead of the default 72.


Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
  - Before


https://github.com/user-attachments/assets/a895530c-2f73-470c-97fa-29d9467c14e1

  - After


https://github.com/user-attachments/assets/ffbe1ba2-0ccc-4b02-87f5-836da7841dd9


- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Closes #ISSUE

Release Notes:

- Fixed commit title length check miscounting multi-byte characters as
multiple characters.
---
 crates/git_ui/src/commit_modal.rs |  6 +++--
 crates/git_ui/src/git_panel.rs    | 43 ++++++++++++++++++++++++++++++-
 2 files changed, 46 insertions(+), 3 deletions(-)

diff --git a/crates/git_ui/src/commit_modal.rs b/crates/git_ui/src/commit_modal.rs
index 3ec5453f9b7..5da2f670f31 100644
--- a/crates/git_ui/src/commit_modal.rs
+++ b/crates/git_ui/src/commit_modal.rs
@@ -1,5 +1,7 @@
 use crate::branch_picker::{self, BranchList};
-use crate::git_panel::{GitPanel, commit_message_editor, panel_editor_style};
+use crate::git_panel::{
+    GitPanel, commit_message_editor, commit_title_exceeds_limit, panel_editor_style,
+};
 use crate::git_panel_settings::GitPanelSettings;
 use git::repository::CommitOptions;
 use git::{Amend, Commit, GenerateCommitMessage, Signoff};
@@ -548,7 +550,7 @@ impl Render for CommitModal {
                 .text(cx)
                 .lines()
                 .next()
-                .is_some_and(|title| title.len() > max_title_length)
+                .is_some_and(|title| commit_title_exceeds_limit(title, max_title_length))
         } else {
             false
         };
diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs
index 9bf5d047c45..04246fcd645 100644
--- a/crates/git_ui/src/git_panel.rs
+++ b/crates/git_ui/src/git_panel.rs
@@ -4566,7 +4566,7 @@ impl GitPanel {
                 .text(cx)
                 .lines()
                 .next()
-                .is_some_and(|title| title.len() > max_title_length)
+                .is_some_and(|title| commit_title_exceeds_limit(title, max_title_length))
         } else {
             false
         };
@@ -7438,6 +7438,10 @@ fn format_git_error_toast_message(error: &anyhow::Error) -> String {
     }
 }
 
+pub(crate) fn commit_title_exceeds_limit(title: &str, max_length: usize) -> bool {
+    max_length > 0 && title.chars().count() > max_length
+}
+
 #[cfg(test)]
 mod tests {
     use git::{
@@ -8916,6 +8920,43 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_commit_title_exceeds_limit() {
+        // ASCII only
+        let within_ascii = "abcde";
+        let exceeds_ascii = "abcdef";
+        assert!(!commit_title_exceeds_limit(within_ascii, 5));
+        assert!(commit_title_exceeds_limit(exceeds_ascii, 5));
+
+        // Multi-byte characters are counted as grapheme clusters
+        let within_japanese = "あいうえお"; // 5 chars, 15 bytes
+        let exceeds_japanese = "あいうえおか"; // 6 chars, 18 bytes
+        assert!(!commit_title_exceeds_limit(within_japanese, 5));
+        assert!(commit_title_exceeds_limit(exceeds_japanese, 5));
+
+        // Mixed ASCII + multi-byte
+        let within_mixed = "abcあ";
+        let exceeds_mixed = "abcああ";
+        assert!(!commit_title_exceeds_limit(within_mixed, 4));
+        assert!(commit_title_exceeds_limit(exceeds_mixed, 4));
+
+        // Emoji counts as one character each
+        let within_emoji = "🚀";
+        let exceeds_emoji = "🚀🚀";
+        assert!(!commit_title_exceeds_limit(within_emoji, 1));
+        assert!(commit_title_exceeds_limit(exceeds_emoji, 1));
+
+        // A max_length of 0 disables the limit check
+        assert!(!commit_title_exceeds_limit(
+            "anything goes when disabled",
+            0
+        ));
+        assert!(!commit_title_exceeds_limit("", 0));
+
+        // Empty title never exceeds a positive limit
+        assert!(!commit_title_exceeds_limit("", 72));
+    }
+
     #[gpui::test]
     async fn test_dispatch_context_with_focus_states(cx: &mut TestAppContext) {
         init_test(cx);

From 62c01be72eb72b4a87f13d1fcdb8217a077950e9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=20Houl=C3=A9?=
 <13155277+tomhoule@users.noreply.github.com>
Date: Mon, 18 May 2026 16:49:40 +0200
Subject: [PATCH 002/105] cloud_api_client: Add update_system_settings (#56843)

Wire up the client side of the new `PATCH /client/system_settings`
endpoint added in zed-industries/cloud#2444, so we can persist the
currently selected organization on a per-system basis. This PR only adds
the request types and the client method; hooking it up to the actual
organization switcher in the editor will come next.

The endpoint requires the `x-zed-system-id` header (the server returns
400 without it), so the method does not take an Option like the other
client calls.

Release Notes:

- N/A
---
 .../cloud_api_client/src/cloud_api_client.rs  | 50 +++++++++++++++++++
 crates/cloud_api_types/src/cloud_api_types.rs | 10 ++++
 2 files changed, 60 insertions(+)

diff --git a/crates/cloud_api_client/src/cloud_api_client.rs b/crates/cloud_api_client/src/cloud_api_client.rs
index 1121dc47572..dc00d001d3b 100644
--- a/crates/cloud_api_client/src/cloud_api_client.rs
+++ b/crates/cloud_api_client/src/cloud_api_client.rs
@@ -239,6 +239,56 @@ impl CloudApiClient {
         serde_json::from_str(&body).map_err(|e| ClientApiError::InvalidResponse(e.into()))
     }
 
+    pub async fn update_system_settings(
+        &self,
+        system_id: String,
+        body: UpdateSystemSettingsBody,
+    ) -> Result<SystemSettings, ClientApiError> {
+        let host = self.cloud_host();
+        let request_builder = Request::builder()
+            .method(Method::PATCH)
+            .uri(
+                self.http_client
+                    .build_zed_cloud_url("/client/system_settings")
+                    .map_err(ClientApiError::RequestBuildFailed)?
+                    .as_ref(),
+            )
+            .header(ZED_SYSTEM_ID_HEADER_NAME, system_id);
+
+        let request = self.build_request(request_builder, Json(body))?;
+
+        let mut response = self.http_client.send(request).await.map_err(|source| {
+            ClientApiError::ConnectionFailed {
+                host: host.clone(),
+                source,
+            }
+        })?;
+
+        if !response.status().is_success() {
+            if response.status() == StatusCode::UNAUTHORIZED {
+                return Err(ClientApiError::Unauthorized);
+            }
+
+            let mut body = String::new();
+            response.body_mut().read_to_string(&mut body).await.ok();
+
+            return Err(ClientApiError::ServerError {
+                host,
+                status: response.status(),
+                body,
+            });
+        }
+
+        let mut body = String::new();
+        response
+            .body_mut()
+            .read_to_string(&mut body)
+            .await
+            .map_err(|e| ClientApiError::InvalidResponse(e.into()))?;
+
+        serde_json::from_str(&body).map_err(|e| ClientApiError::InvalidResponse(e.into()))
+    }
+
     pub async fn validate_credentials(&self, user_id: u32, access_token: &str) -> Result<bool> {
         let request = build_request(
             Request::builder().method(Method::GET).uri(
diff --git a/crates/cloud_api_types/src/cloud_api_types.rs b/crates/cloud_api_types/src/cloud_api_types.rs
index 8966d02d0de..0422c4fa035 100644
--- a/crates/cloud_api_types/src/cloud_api_types.rs
+++ b/crates/cloud_api_types/src/cloud_api_types.rs
@@ -87,6 +87,16 @@ pub struct CreateLlmTokenResponse {
     pub token: LlmToken,
 }
 
+#[derive(Debug, Default, PartialEq, Clone, Serialize, Deserialize)]
+pub struct UpdateSystemSettingsBody {
+    pub selected_organization_id: Option<OrganizationId>,
+}
+
+#[derive(Debug, Default, PartialEq, Clone, Serialize, Deserialize)]
+pub struct SystemSettings {
+    pub selected_organization_id: Option<OrganizationId>,
+}
+
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 pub struct SubmitAgentThreadFeedbackBody {
     pub organization_id: Option<OrganizationId>,

From 988f083fc515095d440de5d813074c2cf8740f4d Mon Sep 17 00:00:00 2001
From: Neel <neel@zed.dev>
Date: Mon, 18 May 2026 15:59:50 +0100
Subject: [PATCH 003/105] docs: Update threshold billing section (#57060)

Release Notes:

- N/A
---
 docs/src/ai/billing.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/docs/src/ai/billing.md b/docs/src/ai/billing.md
index 219f2fae1da..d5fc6750e83 100644
--- a/docs/src/ai/billing.md
+++ b/docs/src/ai/billing.md
@@ -30,6 +30,8 @@ For example,
 - You use $12 of incremental tokens in the month of February, with the first $10 spent on February 15. You'll receive an invoice for $10 on February 15.
 - On March 1, you receive an invoice for $12: $10 (March Pro subscription) and $2 in leftover token spend, since your usage didn't cross the $10 threshold.
 
+For high-volume users, the threshold automatically scales up over time to keep invoicing manageable, so subsequent invoices may trigger at larger increments rather than every $10.
+
 ### Payment failures {#payment-failures}
 
 If payment of an invoice fails, Zed will block usage of our hosted models until the payment is complete. Email [billing-support@zed.dev](mailto:billing-support@zed.dev) for assistance.

From d3d5fb0d15173e68fd2d01195c1b0b2f096ca379 Mon Sep 17 00:00:00 2001
From: Neel <neel@zed.dev>
Date: Mon, 18 May 2026 16:09:21 +0100
Subject: [PATCH 004/105] zed: Improve `zed://` URL handling (#57047)

Release Notes:

- Improved `zed://` and `zed://agent` URL handling
---
 crates/workspace/src/workspace.rs   | 12 ++---
 crates/zed/src/main.rs              | 31 ++++++++++++
 crates/zed/src/zed/open_listener.rs | 73 ++++++++++++++++++++++++++++-
 3 files changed, 109 insertions(+), 7 deletions(-)

diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 90e497eb4e2..da8ffe972ee 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -670,7 +670,11 @@ fn prompt_and_open_paths(
     create_new_window: bool,
     cx: &mut App,
 ) {
-    if let Some(workspace_window) = local_workspace_windows(cx).into_iter().next() {
+    if let Some(workspace_window) =
+        workspace_windows_for_location(&SerializedWorkspaceLocation::Local, cx)
+            .into_iter()
+            .next()
+    {
         workspace_window
             .update(cx, |multi_workspace, window, cx| {
                 let workspace = multi_workspace.workspace().clone();
@@ -9471,7 +9475,7 @@ pub async fn get_any_active_multi_workspace(
     activate_any_workspace_window(&mut cx).context("could not open zed")
 }
 
-fn activate_any_workspace_window(cx: &mut AsyncApp) -> Option<WindowHandle<MultiWorkspace>> {
+pub fn activate_any_workspace_window(cx: &mut AsyncApp) -> Option<WindowHandle<MultiWorkspace>> {
     cx.update(|cx| {
         if let Some(workspace_window) = cx
             .active_window()
@@ -9492,10 +9496,6 @@ fn activate_any_workspace_window(cx: &mut AsyncApp) -> Option<WindowHandle<Multi
     })
 }
 
-pub fn local_workspace_windows(cx: &App) -> Vec<WindowHandle<MultiWorkspace>> {
-    workspace_windows_for_location(&SerializedWorkspaceLocation::Local, cx)
-}
-
 pub fn workspace_windows_for_location(
     serialized_location: &SerializedWorkspaceLocation,
     cx: &App,
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index affe1521a68..4cbbf700f57 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -925,6 +925,14 @@ fn main() {
             .ok()
             .and_then(|request| OpenRequest::parse(request, cx).log_err())
         {
+            Some(request) if request.is_focus_app_only() => cx.spawn({
+                let app_state = app_state.clone();
+                async move |cx| {
+                    if let Err(e) = restore_or_create_workspace(app_state, cx).await {
+                        fail_to_open_window_async(e, cx)
+                    }
+                }
+            }),
             Some(request) => {
                 handle_open_request(request, app_state.clone(), cx);
                 Task::ready(())
@@ -978,6 +986,15 @@ fn handle_open_request(request: OpenRequest, app_state: Arc<AppState>, cx: &mut
                 cx.spawn(async move |cx| handle_cli_connection(connection, app_state, cx).await)
                     .detach();
             }
+            OpenRequestKind::FocusApp => {
+                cx.spawn(async move |cx| {
+                    if workspace::activate_any_workspace_window(cx).is_some() {
+                        return anyhow::Ok(());
+                    }
+                    restore_or_create_workspace(app_state, cx).await
+                })
+                .detach_and_log_err(cx);
+            }
             OpenRequestKind::Extension { extension_id } => {
                 cx.spawn(async move |cx| {
                     let workspace =
@@ -1001,6 +1018,15 @@ fn handle_open_request(request: OpenRequest, app_state: Arc<AppState>, cx: &mut
                     let multi_workspace =
                         workspace::get_any_active_multi_workspace(app_state, cx.clone()).await?;
 
+                    let panels_task = multi_workspace.update(cx, |multi_workspace, _, cx| {
+                        multi_workspace
+                            .workspace()
+                            .update(cx, |workspace, _| workspace.take_panels_task())
+                    })?;
+                    if let Some(task) = panels_task {
+                        task.await.log_err();
+                    }
+
                     multi_workspace.update(cx, |multi_workspace, window, cx| {
                         multi_workspace.workspace().update(cx, |workspace, cx| {
                             if let Some(panel) = workspace.focus_panel::<AgentPanel>(window, cx) {
@@ -1011,6 +1037,11 @@ fn handle_open_request(request: OpenRequest, app_state: Arc<AppState>, cx: &mut
                                         cx,
                                     );
                                 });
+                            } else {
+                                log::warn!(
+                                    "zed://agent received but the AgentPanel is not registered \
+                                     (is `disable_ai` enabled?)"
+                                );
                             }
                         });
                     })
diff --git a/crates/zed/src/zed/open_listener.rs b/crates/zed/src/zed/open_listener.rs
index 0ac86e9d2b5..1544b877dcc 100644
--- a/crates/zed/src/zed/open_listener.rs
+++ b/crates/zed/src/zed/open_listener.rs
@@ -51,6 +51,7 @@ pub enum OpenRequestKind {
             Box<dyn CliResponseSink>,
         ),
     ),
+    FocusApp,
     Extension {
         extension_id: String,
     },
@@ -82,6 +83,7 @@ impl std::fmt::Debug for OpenRequestKind {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::CliConnection(_) => write!(f, "CliConnection(..)"),
+            Self::FocusApp => write!(f, "FocusApp"),
             Self::Extension { extension_id } => f
                 .debug_struct("Extension")
                 .field("extension_id", extension_id)
@@ -118,6 +120,15 @@ impl std::fmt::Debug for OpenRequestKind {
 }
 
 impl OpenRequest {
+    pub fn is_focus_app_only(&self) -> bool {
+        matches!(self.kind, Some(OpenRequestKind::FocusApp))
+            && self.open_paths.is_empty()
+            && self.diff_paths.is_empty()
+            && self.remote_connection.is_none()
+            && self.join_channel.is_none()
+            && self.open_channel_notes.is_empty()
+    }
+
     pub fn parse(request: RawOpenRequest, cx: &App) -> Result<Self> {
         let mut this = Self::default();
 
@@ -167,6 +178,8 @@ impl OpenRequest {
                 }
             } else if let Some(agent_path) = url.strip_prefix("zed://agent") {
                 this.parse_agent_url(agent_path)
+            } else if url == "zed://" || url == "zed://open" || url == "zed://open/" {
+                this.kind = Some(OpenRequestKind::FocusApp);
             } else if let Some(schema_path) = url.strip_prefix("zed://schemas/") {
                 this.kind = Some(OpenRequestKind::BuiltinJsonSchema {
                     schema_path: schema_path.to_string(),
@@ -210,7 +223,8 @@ impl OpenRequest {
     }
 
     fn parse_agent_url(&mut self, agent_path: &str) {
-        // Format: "" or "?prompt=<text>"
+        // Format: "" or "?prompt=<text>".
+        let agent_path = agent_path.strip_prefix('/').unwrap_or(agent_path);
         let external_source_prompt = agent_path.strip_prefix('?').and_then(|query| {
             url::form_urlencoded::parse(query.as_bytes())
                 .find_map(|(key, value)| (key == "prompt").then_some(value))
@@ -1230,6 +1244,63 @@ mod tests {
         }
     }
 
+    #[gpui::test]
+    fn test_parse_agent_url_with_trailing_slash(cx: &mut TestAppContext) {
+        let _app_state = init_test(cx);
+
+        let request = cx.update(|cx| {
+            OpenRequest::parse(
+                RawOpenRequest {
+                    urls: vec!["zed://agent/?prompt=hello".into()],
+                    ..Default::default()
+                },
+                cx,
+            )
+            .unwrap()
+        });
+
+        match request.kind {
+            Some(OpenRequestKind::AgentPanel {
+                external_source_prompt,
+            }) => {
+                assert_eq!(
+                    external_source_prompt
+                        .as_ref()
+                        .map(ExternalSourcePrompt::as_str),
+                    Some("hello")
+                );
+            }
+            _ => panic!("Expected AgentPanel kind"),
+        }
+    }
+
+    #[gpui::test]
+    fn test_parse_focus_app_url(cx: &mut TestAppContext) {
+        let _app_state = init_test(cx);
+
+        for url in ["zed://", "zed://open", "zed://open/"] {
+            let request = cx.update(|cx| {
+                OpenRequest::parse(
+                    RawOpenRequest {
+                        urls: vec![url.into()],
+                        ..Default::default()
+                    },
+                    cx,
+                )
+                .unwrap()
+            });
+            assert!(
+                matches!(request.kind, Some(OpenRequestKind::FocusApp)),
+                "expected FocusApp for {url}, got {:?}",
+                request.kind
+            );
+            assert!(
+                request.is_focus_app_only(),
+                "expected is_focus_app_only for {url}"
+            );
+        }
+    }
+
     #[gpui::test]
     fn test_parse_agent_url_with_empty_prompt(cx: &mut TestAppContext) {
         let _app_state = init_test(cx);

From 342580531ccb6f3ccd78f94e70672e8df3a16840 Mon Sep 17 00:00:00 2001
From: Ben Kunkle <ben@zed.dev>
Date: Mon, 18 May 2026 10:35:35 -0500
Subject: [PATCH 005/105] script: Trigger docs release (#56953)

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Closes #ISSUE

Release Notes:

- N/A or Added/Fixed/Improved ...
---
 script/trigger-docs-build | 50 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100755 script/trigger-docs-build

diff --git a/script/trigger-docs-build b/script/trigger-docs-build
new file mode 100755
index 00000000000..3d429e0097d
--- /dev/null
+++ b/script/trigger-docs-build
@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+which gh >/dev/null || brew install gh
+
+case "${1:-}" in
+  preview | stable)
+    channel="$1"
+    ;;
+  *)
+    echo "Usage: $0 preview|stable [--from-main]" >&2
+    exit 1
+    ;;
+esac
+
+case "${2:-}" in
+  "")
+    from_main=false
+    ;;
+  --from-main)
+    from_main=true
+    ;;
+  *)
+    echo "Usage: $0 preview|stable [--from-main]" >&2
+    exit 1
+    ;;
+esac
+
+version=$(./script/get-released-version "$channel")
+branch=$(echo "$version" | sed -E 's/^([0-9]+)\.([0-9]+)\.[0-9]+$/v\1.\2.x/')
+workflow_ref="$branch"
+if [ "$from_main" = true ]; then
+  workflow_ref="main"
+fi
+
+echo "Triggering docs build for $channel ($branch) using workflow from $workflow_ref"
+echo "This will publish docs from $branch before the next release."
+echo "Only continue if $branch has no unreleased feature-specific docs."
+read -r -p "Continue? [y/N] " confirmation
+case "$confirmation" in
+  y | Y | yes | YES)
+    ;;
+  *)
+    echo "Cancelled."
+    exit 1
+    ;;
+esac
+
+gh workflow run "deploy_docs.yml" --ref "$workflow_ref" -f channel="$channel" -f checkout_ref="$branch"
+echo "Follow along at: https://github.com/zed-industries/zed/actions/workflows/deploy_docs.yml"

From ea01b926ea4925cccef09f77235c350d1cdc6791 Mon Sep 17 00:00:00 2001
From: Hadley99 <94683523+Hadley99@users.noreply.github.com>
Date: Mon, 18 May 2026 21:24:51 +0530
Subject: [PATCH 006/105] languages: Exclude angle brackets from rainbow
 bracket colorization for Javascript (#57063)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Summary

Extends #51311 to JSX in JavaScript files, which uses the same
javascript grammar for both .js and .jsx.

## Changes

- Added (#set! rainbow.exclude) to the three angle bracket patterns in
crates/grammars/src/javascript/brackets.scm, matching the TSX fix in
#51311.

## Before / After

Before: angle brackets in JSX tags receive rainbow colors alongside
`{}`, `()`, `[]`, making every tag visually noisy.

After: only `{}`, `()`, and `[]` receive rainbow colors — angle brackets
are excluded, matching the HTML extension behavior.

Release Notes:

- Fixed angled brackets being included in rainbow bracket highlights for
JavaScript.
---
 crates/grammars/src/javascript/brackets.scm | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/crates/grammars/src/javascript/brackets.scm b/crates/grammars/src/javascript/brackets.scm
index 69acbcd614e..a5f51bbbb11 100644
--- a/crates/grammars/src/javascript/brackets.scm
+++ b/crates/grammars/src/javascript/brackets.scm
@@ -7,14 +7,17 @@
 ("{" @open
   "}" @close)
 
-("<" @open
+(("<" @open
   ">" @close)
+  (#set! rainbow.exclude))
 
-("<" @open
+(("<" @open
   "/>" @close)
+  (#set! rainbow.exclude))
 
-("</" @open
+(("</" @open
   ">" @close)
+  (#set! rainbow.exclude))
 
 (("\"" @open
   "\"" @close)

From ec9ba5f069f415713a2f2e3e8550c28479678dba Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Mon, 18 May 2026 13:18:59 -0300
Subject: [PATCH 007/105] Make restricted mode more obvious (#57056)

Closes TRA-150

This PR makes the restricted mode more obvious by:

- Immediately opening the restricted mode modal upon opening an
untrusted project
- Disabling dismissing the modal on escape or click away to force
choosing one of the two options (and avoid accidentally staying in
restricted mode by simply dismissing it)
- Showing the LSP button but with communication about language servers
being disabled for untrusted projects
- Showing a banner in the project settings with the same communication

The motivation for this change was that we tried to be minimal with how
we communicate a project is untrusted, but it was so minimal that people
were confused as to why language servers and other settings weren't
working. It was easy to miss the title bar button, for some reason. The
changes in this PR makes it so acting on this decision (trust or not a
project) is mandatory in order to even start to interact with the
project. I appreciate changes here are more aggressive, but I think it's
better to make you think about this decision vs. letting you be confused
as to why you don't see LS completions or formatting.

Release Notes:

- Made restricted mode more obvious, demanding immediate action when
opening an untrusted project.
---
 crates/git_ui/src/worktree_service.rs   | 16 ++---
 crates/language_tools/src/lsp_button.rs | 86 +++++++++++++++++++++----
 crates/project/src/trusted_worktrees.rs | 11 ++++
 crates/settings_ui/src/settings_ui.rs   | 62 +++++++++++++++++-
 crates/title_bar/src/title_bar.rs       |  9 +--
 crates/workspace/src/security_modal.rs  | 14 ++--
 crates/workspace/src/workspace.rs       | 20 ++++--
 7 files changed, 178 insertions(+), 40 deletions(-)

diff --git a/crates/git_ui/src/worktree_service.rs b/crates/git_ui/src/worktree_service.rs
index 0ec34f3d915..1eda4219092 100644
--- a/crates/git_ui/src/worktree_service.rs
+++ b/crates/git_ui/src/worktree_service.rs
@@ -252,17 +252,11 @@ fn maybe_propagate_worktree_trust(
         if ProjectSettings::get_global(cx).session.trust_all_worktrees {
             return;
         }
-        let Some(trusted_store) = TrustedWorktrees::try_get_global(cx) else {
-            return;
-        };
-
         let source_is_trusted = source_workspace
             .upgrade()
             .map(|workspace| {
                 let source_worktree_store = workspace.read(cx).project().read(cx).worktree_store();
-                !trusted_store
-                    .read(cx)
-                    .has_restricted_worktrees(&source_worktree_store, cx)
+                !TrustedWorktrees::has_restricted_worktrees(&source_worktree_store, cx)
             })
             .unwrap_or(false);
 
@@ -280,9 +274,11 @@ fn maybe_propagate_worktree_trust(
             .collect();
 
         if !paths_to_trust.is_empty() {
-            trusted_store.update(cx, |store, cx| {
-                store.trust(&worktree_store, paths_to_trust, cx);
-            });
+            if let Some(trusted_store) = TrustedWorktrees::try_get_global(cx) {
+                trusted_store.update(cx, |store, cx| {
+                    store.trust(&worktree_store, paths_to_trust, cx);
+                });
+            }
         }
     })
     .ok();
diff --git a/crates/language_tools/src/lsp_button.rs b/crates/language_tools/src/lsp_button.rs
index 8b7088dc228..e7c6d5b2160 100644
--- a/crates/language_tools/src/lsp_button.rs
+++ b/crates/language_tools/src/lsp_button.rs
@@ -13,12 +13,12 @@ use language::language_settings::{EditPredictionProvider, all_language_settings}
 use client::proto;
 use collections::HashSet;
 use editor::{Editor, EditorEvent};
-use gpui::{Anchor, App, Entity, Subscription, Task, TaskExt, WeakEntity, actions};
+use gpui::{Action as _, Anchor, App, Entity, Subscription, Task, TaskExt, WeakEntity, actions};
 use language::{BinaryStatus, BufferId, ServerHealth};
 use lsp::{LanguageServerId, LanguageServerName, LanguageServerSelector};
 use project::{
     LspStore, LspStoreEvent, Worktree, lsp_store::log_store::GlobalLogStore,
-    project_settings::ProjectSettings,
+    project_settings::ProjectSettings, trusted_worktrees::TrustedWorktrees,
 };
 use settings::{Settings as _, SettingsStore};
 use ui::{
@@ -26,7 +26,7 @@ use ui::{
 };
 
 use util::{ResultExt, paths::PathExt, rel_path::RelPath};
-use workspace::{StatusItemView, Workspace};
+use workspace::{StatusItemView, ToggleWorktreeSecurity, Workspace};
 
 use crate::lsp_log_view;
 
@@ -221,6 +221,45 @@ impl LanguageServerState {
             return menu;
         };
 
+        let is_restricted = self
+            .workspace
+            .upgrade()
+            .map(|workspace| {
+                let worktree_store = workspace.read(cx).project().read(cx).worktree_store();
+                TrustedWorktrees::has_restricted_worktrees(&worktree_store, cx)
+            })
+            .unwrap_or(false);
+
+        if is_restricted {
+            menu = menu.custom_entry(
+                move |_window, _cx| {
+                    v_flex()
+                        .child(
+                            h_flex()
+                                .gap_1()
+                                .child(
+                                    Icon::new(IconName::Warning)
+                                        .color(Color::Warning)
+                                        .size(IconSize::XSmall),
+                                )
+                                .child(
+                                    Label::new("Project is in Restricted Mode")
+                                        .size(LabelSize::Small),
+                                ),
+                        )
+                        .child(
+                            Label::new("Language Servers can't run until you trust this project.")
+                                .size(LabelSize::Small)
+                                .color(Color::Muted),
+                        )
+                        .into_any_element()
+                },
+                move |window, cx| {
+                    window.dispatch_action(ToggleWorktreeSecurity.boxed_clone(), cx);
+                },
+            );
+        }
+
         let server_metadata = self
             .lsp_store
             .update(cx, |lsp_store, _| {
@@ -832,12 +871,18 @@ impl LspButton {
             lsp_menu_refresh: Task::ready(()),
             _subscriptions: vec![settings_subscription, lsp_store_subscription],
         };
-        if !lsp_button
-            .server_state
-            .read(cx)
-            .language_servers
-            .binary_statuses
-            .is_empty()
+        let is_restricted = TrustedWorktrees::has_restricted_worktrees(
+            &workspace.project().read(cx).worktree_store(),
+            cx,
+        );
+
+        if is_restricted
+            || !lsp_button
+                .server_state
+                .read(cx)
+                .language_servers
+                .binary_statuses
+                .is_empty()
         {
             lsp_button.refresh_lsp_menu(true, window, cx);
         }
@@ -1258,7 +1303,20 @@ impl StatusItemView for LspButton {
 
 impl Render for LspButton {
     fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl ui::IntoElement {
-        if self.server_state.read(cx).language_servers.is_empty() || self.lsp_menu.is_none() {
+        let is_restricted = self
+            .server_state
+            .read(cx)
+            .workspace
+            .upgrade()
+            .map(|workspace| {
+                let worktree_store = workspace.read(cx).project().read(cx).worktree_store();
+                TrustedWorktrees::has_restricted_worktrees(&worktree_store, cx)
+            })
+            .unwrap_or(false);
+
+        if !is_restricted
+            && (self.server_state.read(cx).language_servers.is_empty() || self.lsp_menu.is_none())
+        {
             return div().hidden();
         }
 
@@ -1288,7 +1346,12 @@ impl Render for LspButton {
             }
         }
 
-        let (indicator, description) = if has_errors {
+        let (indicator, description) = if is_restricted {
+            (
+                Some(Indicator::dot().color(Color::Warning)),
+                "Restricted Mode",
+            )
+        } else if has_errors {
             (
                 Some(Indicator::dot().color(Color::Error)),
                 "Server with errors",
@@ -1333,6 +1396,7 @@ impl Render for LspButton {
                     IconButton::new("zed-lsp-tool-button", IconName::BoltOutlined)
                         .when_some(indicator, IconButton::indicator)
                         .icon_size(IconSize::Small)
+                        .when(is_restricted, |s| s.icon_color(Color::Warning))
                         .indicator_border_color(Some(cx.theme().colors().status_bar_background)),
                     move |_window, cx| {
                         Tooltip::with_meta("Language Servers", Some(&ToggleMenu), description, cx)
diff --git a/crates/project/src/trusted_worktrees.rs b/crates/project/src/trusted_worktrees.rs
index 69d410adc66..8d8804c3f97 100644
--- a/crates/project/src/trusted_worktrees.rs
+++ b/crates/project/src/trusted_worktrees.rs
@@ -113,6 +113,17 @@ impl TrustedWorktrees {
     pub fn try_get_global(cx: &App) -> Option<Entity<TrustedWorktreesStore>> {
         cx.try_global::<Self>().map(|this| this.0.clone())
     }
+
+    /// Whether the given project store has any restricted worktrees.
+    pub fn has_restricted_worktrees(worktree_store: &Entity<WorktreeStore>, cx: &App) -> bool {
+        Self::try_get_global(cx)
+            .map(|trusted| {
+                trusted
+                    .read(cx)
+                    .has_restricted_worktrees(worktree_store, cx)
+            })
+            .unwrap_or(false)
+    }
 }
 
 /// A collection of worktrees that are considered trusted and not trusted.
diff --git a/crates/settings_ui/src/settings_ui.rs b/crates/settings_ui/src/settings_ui.rs
index f8d938e9eec..02bbacdfa30 100644
--- a/crates/settings_ui/src/settings_ui.rs
+++ b/crates/settings_ui/src/settings_ui.rs
@@ -3350,6 +3350,65 @@ impl SettingsWindow {
                 .into_any_element()
         }
 
+        let mut restricted_banner = gpui::Empty.into_any_element();
+        if let SettingsUiFile::Project((worktree_id, _)) = &self.current_file {
+            let worktree_id = *worktree_id;
+            let is_restricted = all_projects(self.original_window.as_ref(), cx)
+                .find(|project| project.read(cx).worktree_for_id(worktree_id, cx).is_some())
+                .map(|project| {
+                    let worktree_store = project.read(cx).worktree_store();
+                    project::trusted_worktrees::TrustedWorktrees::has_restricted_worktrees(
+                        &worktree_store,
+                        cx,
+                    )
+                })
+                .unwrap_or(false);
+
+            if is_restricted {
+                let original_window = self.original_window;
+                restricted_banner = Banner::new()
+                    .severity(Severity::Warning)
+                    .child(
+                        v_flex()
+                            .my_0p5()
+                            .gap_0p5()
+                            .child(Label::new("Restricted Mode"))
+                            .child(
+                                Label::new(
+                                    "This project is in restricted mode. Some project settings may not apply.",
+                                )
+                                .size(LabelSize::Small)
+                                .color(Color::Muted),
+                            ),
+                    )
+                    .action_slot(
+                        div().pr_2().pb_1().child(
+                            Button::new("manage-trust", "Manage Trust")
+                                .style(ButtonStyle::Tinted(ui::TintColor::Warning))
+                                .on_click(cx.listener(move |_this, _, window, cx| {
+                                    if let Some(original_window) = original_window {
+                                        original_window
+                                            .update(cx, |multi_workspace, window, cx| {
+                                                multi_workspace
+                                                    .workspace()
+                                                    .update(cx, |workspace, cx| {
+                                                        workspace
+                                                            .show_worktree_trust_security_modal(
+                                                                true, window, cx,
+                                                            );
+                                                    });
+                                            })
+                                            .log_err();
+                                    }
+                                    // Close the settings window
+                                    window.remove_window();
+                                })),
+                        ),
+                    )
+                    .into_any_element();
+            }
+        }
+
         v_flex()
             .id("settings-ui-page")
             .on_action(cx.listener(|this, _: &menu::SelectNext, window, cx| {
@@ -3440,7 +3499,8 @@ impl SettingsWindow {
                     .px_8()
                     .gap_2()
                     .child(page_header)
-                    .child(warning_banner),
+                    .child(warning_banner)
+                    .child(restricted_banner),
             )
             .child(
                 div()
diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs
index c15f840e69d..3bc12a20748 100644
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -641,13 +641,8 @@ impl TitleBar {
     }
 
     pub fn render_restricted_mode(&self, cx: &mut Context<Self>) -> Option<AnyElement> {
-        let has_restricted_worktrees = TrustedWorktrees::try_get_global(cx)
-            .map(|trusted_worktrees| {
-                trusted_worktrees
-                    .read(cx)
-                    .has_restricted_worktrees(&self.project.read(cx).worktree_store(), cx)
-            })
-            .unwrap_or(false);
+        let has_restricted_worktrees =
+            TrustedWorktrees::has_restricted_worktrees(&self.project.read(cx).worktree_store(), cx);
         if !has_restricted_worktrees {
             return None;
         }
diff --git a/crates/workspace/src/security_modal.rs b/crates/workspace/src/security_modal.rs
index 2130a1d1eca..89ce2abfd66 100644
--- a/crates/workspace/src/security_modal.rs
+++ b/crates/workspace/src/security_modal.rs
@@ -56,11 +56,17 @@ impl ModalView for SecurityModal {
 
     fn on_before_dismiss(&mut self, _: &mut Window, _: &mut Context<Self>) -> DismissDecision {
         match self.trusted {
-            Some(false) => telemetry::event!("Open in Restricted", source = "Worktree Trust Modal"),
-            Some(true) => telemetry::event!("Trust and Continue", source = "Worktree Trust Modal"),
-            None => telemetry::event!("Dismissed", source = "Worktree Trust Modal"),
+            Some(false) => {
+                telemetry::event!("Open in Restricted", source = "Worktree Trust Modal");
+                DismissDecision::Dismiss(true)
+            }
+            Some(true) => {
+                telemetry::event!("Trust and Continue", source = "Worktree Trust Modal");
+                DismissDecision::Dismiss(true)
+            }
+            // Block dismiss via escape or clicking outside; user must pick an action
+            None => DismissDecision::Dismiss(false),
         }
-        DismissDecision::Dismiss(true)
     }
 }
 
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index da8ffe972ee..599a2d23681 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -2122,6 +2122,15 @@ impl Workspace {
                     .log_err();
             }
 
+            // Auto-show the security modal if the project has restricted worktrees
+            window
+                .update(cx, |_, window, cx| {
+                    workspace.update(cx, |workspace, cx| {
+                        workspace.show_worktree_trust_security_modal(false, window, cx);
+                    });
+                })
+                .log_err();
+
             Ok(OpenResult {
                 window,
                 workspace,
@@ -8014,13 +8023,10 @@ impl Workspace {
                 });
             }
         } else {
-            let has_restricted_worktrees = TrustedWorktrees::try_get_global(cx)
-                .map(|trusted_worktrees| {
-                    trusted_worktrees
-                        .read(cx)
-                        .has_restricted_worktrees(&self.project().read(cx).worktree_store(), cx)
-                })
-                .unwrap_or(false);
+            let has_restricted_worktrees = TrustedWorktrees::has_restricted_worktrees(
+                &self.project().read(cx).worktree_store(),
+                cx,
+            );
             if has_restricted_worktrees {
                 let project = self.project().read(cx);
                 let remote_host = project

From b9ba43c9c1f9fc466d27b690ea5e7bea75209110 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Mon, 18 May 2026 13:36:37 -0300
Subject: [PATCH 008/105] agent_ui: Add mention disambiguation (#56926)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closes AI-261

This PR adds mention disambiguation in the agent panel, which works both
for regular @-mentions as well as for skills. Effectively, when you
mention files with the same name, the mention crease displays the next
path parent name, following a similar approach to common tabs in the
editor. For skills, the skill source is displayed (either global or from
some project).

<img width="500" alt="Screenshot 2026-05-15 at 6  32@2x"
src="https://github.com/user-attachments/assets/72c99480-cf32-42ac-9304-3f65167a1d94"
/>

Release Notes:

- Agent: Improved file and skill mention disambiguation in the agent
panel.

---------

Co-authored-by: Richard Feldman <richard@zed.dev>
---
 crates/acp_thread/src/mention.rs           |  83 ++++++++++++++
 crates/agent_ui/src/completion_provider.rs |   4 +-
 crates/agent_ui/src/mention_set.rs         | 124 ++++++++++++++++-----
 crates/agent_ui/src/message_editor.rs      |  54 ++++++---
 4 files changed, 224 insertions(+), 41 deletions(-)

diff --git a/crates/acp_thread/src/mention.rs b/crates/acp_thread/src/mention.rs
index 6fc2cc50c1f..67c1ddb9416 100644
--- a/crates/acp_thread/src/mention.rs
+++ b/crates/acp_thread/src/mention.rs
@@ -342,6 +342,21 @@ impl MentionUri {
                 ..
             } => selection_name(path.as_deref(), line_range),
             MentionUri::Fetch { url } => url.to_string(),
+            MentionUri::Skill { name, .. } => name.clone(),
+        }
+    }
+
+    /// Returns a label for this mention at the given disambiguation `detail`
+    /// level. `detail == 0` is the base name returned by [`Self::name`]; higher
+    /// levels include progressively more context (e.g. additional parent path
+    /// components for files, or the source for skills) until a fixed point is
+    /// reached. Intended to be driven by [`util::disambiguate::compute_disambiguation_details`].
+    pub fn disambiguated_name(&self, detail: usize) -> String {
+        if detail == 0 {
+            return self.name();
+        }
+
+        match self {
             MentionUri::Skill { name, source, .. } => {
                 if source.is_empty() {
                     format!("{} (global)", name)
@@ -349,6 +364,10 @@ impl MentionUri {
                     format!("{} ({})", name, source)
                 }
             }
+            MentionUri::File { abs_path, .. } | MentionUri::Directory { abs_path, .. } => {
+                project::path_suffix(abs_path, detail)
+            }
+            _ => self.name(),
         }
     }
 
@@ -1070,4 +1089,68 @@ mod tests {
         let parsed_single = MentionUri::parse(single_line_uri, PathStyle::local()).unwrap();
         assert_eq!(parsed_single.name(), "Terminal (1 line)");
     }
+
+    #[test]
+    fn test_disambiguated_name() {
+        // Two files with the same name — should disambiguate with parent dir
+        let file_a = MentionUri::File {
+            abs_path: PathBuf::from(path!("/project/src/README.md")),
+        };
+        let file_b = MentionUri::File {
+            abs_path: PathBuf::from(path!("/project/docs/README.md")),
+        };
+        assert_eq!(file_a.name(), "README.md");
+        assert_eq!(file_b.name(), "README.md");
+        assert_eq!(file_a.disambiguated_name(0), "README.md");
+        assert_eq!(file_a.disambiguated_name(1), "src/README.md");
+        assert_eq!(file_b.disambiguated_name(1), "docs/README.md");
+
+        // Files that still collide at one parent should grow further.
+        let deep_a = MentionUri::File {
+            abs_path: PathBuf::from(path!("/a/src/foo.rs")),
+        };
+        let deep_b = MentionUri::File {
+            abs_path: PathBuf::from(path!("/b/src/foo.rs")),
+        };
+        assert_eq!(deep_a.disambiguated_name(1), "src/foo.rs");
+        assert_eq!(deep_b.disambiguated_name(1), "src/foo.rs");
+        assert_eq!(deep_a.disambiguated_name(2), "a/src/foo.rs");
+        assert_eq!(deep_b.disambiguated_name(2), "b/src/foo.rs");
+
+        // Two skills with the same name — should disambiguate with source
+        let global_skill = MentionUri::Skill {
+            name: "create-skill".into(),
+            source: "".into(),
+            skill_file_path: PathBuf::from("/global/create-skill/SKILL.md"),
+        };
+        let project_skill = MentionUri::Skill {
+            name: "create-skill".into(),
+            source: "my-project".into(),
+            skill_file_path: PathBuf::from("/project/create-skill/SKILL.md"),
+        };
+        assert_eq!(global_skill.name(), "create-skill");
+        assert_eq!(global_skill.disambiguated_name(0), "create-skill");
+        assert_eq!(global_skill.disambiguated_name(1), "create-skill (global)");
+        assert_eq!(
+            project_skill.disambiguated_name(1),
+            "create-skill (my-project)"
+        );
+
+        // A type without special disambiguation (Thread) — detail has no effect
+        // (the value is a fixed point so the disambiguation loop terminates).
+        let thread = MentionUri::Thread {
+            id: acp::SessionId::new("123"),
+            name: "My Thread".into(),
+        };
+        assert_eq!(thread.disambiguated_name(0), "My Thread");
+        assert_eq!(thread.disambiguated_name(1), "My Thread");
+        assert_eq!(thread.disambiguated_name(5), "My Thread");
+
+        // Edge case: file at filesystem root has no parent to show
+        let root_file = MentionUri::File {
+            abs_path: PathBuf::from(path!("/README.md")),
+        };
+        assert_eq!(root_file.disambiguated_name(1), "README.md");
+        assert_eq!(root_file.disambiguated_name(5), "README.md");
+    }
 }
diff --git a/crates/agent_ui/src/completion_provider.rs b/crates/agent_ui/src/completion_provider.rs
index 37074aa35a2..3a4ae6ecc2b 100644
--- a/crates/agent_ui/src/completion_provider.rs
+++ b/crates/agent_ui/src/completion_provider.rs
@@ -2603,7 +2603,7 @@ fn completion_text_for_terminal_selections(
                     };
 
                     mention_set
-                        .update(cx, |mention_set, _| {
+                        .update(cx, |mention_set, cx| {
                             mention_set.insert_mention(
                                 crease_id,
                                 mention_uri.clone(),
@@ -2612,6 +2612,8 @@ fn completion_text_for_terminal_selections(
                                     tracked_buffers: vec![],
                                 }))
                                 .shared(),
+                                None,
+                                cx,
                             );
                         })
                         .ok();
diff --git a/crates/agent_ui/src/mention_set.rs b/crates/agent_ui/src/mention_set.rs
index 17ad11d3288..31bb31c046c 100644
--- a/crates/agent_ui/src/mention_set.rs
+++ b/crates/agent_ui/src/mention_set.rs
@@ -63,6 +63,7 @@ pub struct MentionSet {
     thread_store: Option<Entity<ThreadStore>>,
     prompt_store: Option<Entity<PromptStore>>,
     mentions: HashMap<CreaseId, (MentionUri, MentionTask)>,
+    crease_entities: HashMap<CreaseId, Entity<LoadingContext>>,
 }
 
 impl MentionSet {
@@ -76,6 +77,7 @@ impl MentionSet {
             thread_store,
             prompt_store,
             mentions: HashMap::default(),
+            crease_entities: HashMap::default(),
         }
     }
 
@@ -110,12 +112,24 @@ impl MentionSet {
         for (crease_id, crease) in snapshot.crease_snapshot.creases() {
             if !crease.range().start.is_valid(snapshot.buffer_snapshot()) {
                 self.mentions.remove(&crease_id);
+                self.crease_entities.remove(&crease_id);
             }
         }
     }
 
-    pub fn insert_mention(&mut self, crease_id: CreaseId, uri: MentionUri, task: MentionTask) {
+    pub fn insert_mention(
+        &mut self,
+        crease_id: CreaseId,
+        uri: MentionUri,
+        task: MentionTask,
+        crease_entity: Option<Entity<LoadingContext>>,
+        cx: &mut App,
+    ) {
         self.mentions.insert(crease_id, (uri, task));
+        if let Some(entity) = crease_entity {
+            self.crease_entities.insert(crease_id, entity);
+        }
+        self.recompute_disambiguation(cx);
     }
 
     /// Creates the appropriate confirmation task for a mention based on its URI type.
@@ -165,8 +179,10 @@ impl MentionSet {
         }
     }
 
-    pub fn remove_mention(&mut self, crease_id: &CreaseId) {
+    pub fn remove_mention(&mut self, crease_id: &CreaseId, cx: &mut App) {
         self.mentions.remove(crease_id);
+        self.crease_entities.remove(crease_id);
+        self.recompute_disambiguation(cx);
     }
 
     pub fn creases(&self) -> HashSet<CreaseId> {
@@ -196,13 +212,32 @@ impl MentionSet {
     }
 
     pub fn set_mentions(&mut self, mentions: HashMap<CreaseId, (MentionUri, MentionTask)>) {
+        self.crease_entities
+            .retain(|id, _| mentions.contains_key(id));
         self.mentions = mentions;
     }
 
     pub fn clear(&mut self) -> impl Iterator<Item = (CreaseId, (MentionUri, MentionTask))> {
+        self.crease_entities.clear();
         self.mentions.drain()
     }
 
+    fn recompute_disambiguation(&self, cx: &mut App) {
+        let labels =
+            compute_disambiguated_labels(self.mentions.iter().map(|(id, (uri, _))| (*id, uri)));
+
+        for (crease_id, new_label) in labels {
+            if let Some(entity) = self.crease_entities.get(&crease_id) {
+                entity.update(cx, |loading_ctx, cx| {
+                    if loading_ctx.label != new_label {
+                        loading_ctx.label = new_label;
+                        cx.notify();
+                    }
+                });
+            }
+        }
+    }
+
     pub fn confirm_mention_completion(
         &mut self,
         crease_text: SharedString,
@@ -273,7 +308,7 @@ impl MentionSet {
                 cx,
             )
         };
-        let Some((crease_id, tx)) = crease else {
+        let Some((crease_id, tx, crease_entity)) = crease else {
             return Task::ready(());
         };
 
@@ -325,6 +360,10 @@ impl MentionSet {
             .spawn(async move |_, _| task.await.map_err(|e| e.to_string()))
             .shared();
         self.mentions.insert(crease_id, (mention_uri, task.clone()));
+        if let Some(entity) = crease_entity {
+            self.crease_entities.insert(crease_id, entity);
+        }
+        self.recompute_disambiguation(cx);
 
         // Notify the user if we failed to load the mentioned context
         let workspace = workspace.downgrade();
@@ -338,6 +377,7 @@ impl MentionSet {
                         editor.edit([(start_anchor..end_anchor, "")], cx);
                     });
                     this.mentions.remove(&crease_id);
+                    this.crease_entities.remove(&crease_id);
                 })
                 .ok();
             }
@@ -669,6 +709,26 @@ impl MentionSet {
     }
 }
 
+/// Computes disambiguated labels for a set of mentions. When multiple mentions
+/// share the same base name, their labels include extra context (additional
+/// parent path components for files/directories, source for skills) so the user
+/// can tell them apart. Driven by [`util::disambiguate::compute_disambiguation_details`],
+/// which is the same utility used for buffer tab titles and the sidebar.
+fn compute_disambiguated_labels<'a>(
+    mentions: impl Iterator<Item = (CreaseId, &'a MentionUri)>,
+) -> HashMap<CreaseId, SharedString> {
+    let mentions: Vec<_> = mentions.collect();
+    let details =
+        util::disambiguate::compute_disambiguation_details(&mentions, |(_, uri), detail| {
+            uri.disambiguated_name(detail)
+        });
+    mentions
+        .into_iter()
+        .zip(details)
+        .map(|((id, uri), detail)| (id, uri.disambiguated_name(detail).into()))
+        .collect()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -821,7 +881,7 @@ pub(crate) async fn insert_images_as_context(
             snapshot.anchor_before(start_anchor.to_offset(&snapshot) + content_len)
         });
         let image = Arc::new(image);
-        let Ok(Some((crease_id, tx))) = cx.update(|window, cx| {
+        let Ok(Some((crease_id, tx, crease_entity))) = cx.update(|window, cx| {
             insert_crease_for_mention(
                 text_anchor,
                 content_len,
@@ -856,13 +916,15 @@ pub(crate) async fn insert_images_as_context(
             })
             .shared();
 
-        mention_set.update(cx, |mention_set, _cx| {
+        mention_set.update(cx, |mention_set, cx| {
             mention_set.insert_mention(
                 crease_id,
                 MentionUri::PastedImage {
                     name: name.to_string(),
                 },
                 task.clone(),
+                crease_entity,
+                cx,
             )
         });
 
@@ -874,8 +936,8 @@ pub(crate) async fn insert_images_as_context(
             editor.update(cx, |editor, cx| {
                 editor.edit([(start_anchor..end_anchor, "")], cx);
             });
-            mention_set.update(cx, |mention_set, _cx| {
-                mention_set.remove_mention(&crease_id)
+            mention_set.update(cx, |mention_set, cx| {
+                mention_set.remove_mention(&crease_id, cx)
             });
         }
     }
@@ -991,7 +1053,11 @@ pub(crate) fn insert_crease_for_mention(
     editor: Entity<Editor>,
     window: &mut Window,
     cx: &mut App,
-) -> Option<(CreaseId, postage::barrier::Sender)> {
+) -> Option<(
+    CreaseId,
+    postage::barrier::Sender,
+    Option<Entity<LoadingContext>>,
+)> {
     let (tx, rx) = postage::barrier::channel();
 
     let crease_id = editor.update(cx, |editor, cx| {
@@ -1002,19 +1068,20 @@ pub(crate) fn insert_crease_for_mention(
         let start = start.bias_right(&snapshot);
         let end = snapshot.anchor_before(start.to_offset(&snapshot) + content_len);
 
+        let (render, crease_entity) = render_mention_fold_button(
+            crease_label.clone(),
+            crease_icon.clone(),
+            crease_tooltip,
+            mention_uri.clone(),
+            workspace.clone(),
+            start..end,
+            rx,
+            image,
+            cx.weak_entity(),
+            cx,
+        );
         let placeholder = FoldPlaceholder {
-            render: render_mention_fold_button(
-                crease_label.clone(),
-                crease_icon.clone(),
-                crease_tooltip,
-                mention_uri.clone(),
-                workspace.clone(),
-                start..end,
-                rx,
-                image,
-                cx.weak_entity(),
-                cx,
-            ),
+            render,
             merge_adjacent: false,
             ..Default::default()
         };
@@ -1033,10 +1100,11 @@ pub(crate) fn insert_crease_for_mention(
         let ids = editor.insert_creases(vec![crease.clone()], cx);
         editor.fold_creases(vec![crease], false, window, cx);
 
-        Some(ids[0])
+        Some((ids[0], crease_entity))
     })?;
 
-    Some((crease_id, tx))
+    let (crease_id, crease_entity) = crease_id;
+    Some((crease_id, tx, Some(crease_entity)))
 }
 
 pub(crate) fn crease_for_mention(
@@ -1215,7 +1283,10 @@ fn render_mention_fold_button(
     image_task: Option<Shared<Task<Result<Arc<Image>, String>>>>,
     editor: WeakEntity<Editor>,
     cx: &mut App,
-) -> Arc<dyn Send + Sync + Fn(FoldId, Range<Anchor>, &mut App) -> AnyElement> {
+) -> (
+    Arc<dyn Send + Sync + Fn(FoldId, Range<Anchor>, &mut App) -> AnyElement>,
+    Entity<LoadingContext>,
+) {
     let loading = cx.new(|cx| {
         let loading = cx.spawn(async move |this, cx| {
             loading_finished.recv().await;
@@ -1238,10 +1309,13 @@ fn render_mention_fold_button(
             image: image_task.clone(),
         }
     });
-    Arc::new(move |_fold_id, _fold_range, _cx| loading.clone().into_any_element())
+    let loading_clone = loading.clone();
+    let render: Arc<dyn Send + Sync + Fn(FoldId, Range<Anchor>, &mut App) -> AnyElement> =
+        Arc::new(move |_fold_id, _fold_range, _cx| loading_clone.clone().into_any_element());
+    (render, loading)
 }
 
-struct LoadingContext {
+pub struct LoadingContext {
     id: EntityId,
     label: SharedString,
     icon: SharedString,
diff --git a/crates/agent_ui/src/message_editor.rs b/crates/agent_ui/src/message_editor.rs
index 8a152239c14..ecd1febba72 100644
--- a/crates/agent_ui/src/message_editor.rs
+++ b/crates/agent_ui/src/message_editor.rs
@@ -1134,7 +1134,7 @@ impl MessageEditor {
                         (text_anchor, mention_text.len())
                     });
 
-                    let Some((crease_id, tx)) = insert_crease_for_mention(
+                    let Some((crease_id, tx, crease_entity)) = insert_crease_for_mention(
                         text_anchor,
                         content_len,
                         crease_text.into(),
@@ -1181,8 +1181,14 @@ impl MessageEditor {
                         })
                         .shared();
 
-                    self.mention_set.update(cx, |mention_set, _cx| {
-                        mention_set.insert_mention(crease_id, mention_uri.clone(), mention_task)
+                    self.mention_set.update(cx, |mention_set, cx| {
+                        mention_set.insert_mention(
+                            crease_id,
+                            mention_uri.clone(),
+                            mention_task,
+                            crease_entity,
+                            cx,
+                        )
                     });
                 }
             }
@@ -1241,7 +1247,7 @@ impl MessageEditor {
                     let http_client = workspace.read(cx).client().http_client();
 
                     for (anchor, content_len, mention_uri) in all_mentions {
-                        let Some((crease_id, tx)) = insert_crease_for_mention(
+                        let Some((crease_id, tx, crease_entity)) = insert_crease_for_mention(
                             snapshot.anchor_to_buffer_anchor(anchor).unwrap().0,
                             content_len,
                             mention_uri.name().into(),
@@ -1271,8 +1277,14 @@ impl MessageEditor {
                             .spawn(async move |_, _| task.await.map_err(|e| e.to_string()))
                             .shared();
 
-                        self.mention_set.update(cx, |mention_set, _cx| {
-                            mention_set.insert_mention(crease_id, mention_uri.clone(), task.clone())
+                        self.mention_set.update(cx, |mention_set, cx| {
+                            mention_set.insert_mention(
+                                crease_id,
+                                mention_uri.clone(),
+                                task.clone(),
+                                crease_entity,
+                                cx,
+                            )
                         });
 
                         // Drop the tx after inserting to signal the crease is ready
@@ -1463,7 +1475,7 @@ impl MessageEditor {
                         (text_anchor, mention_text.len())
                     });
 
-                    let Some((crease_id, tx)) = insert_crease_for_mention(
+                    let Some((crease_id, tx, crease_entity)) = insert_crease_for_mention(
                         text_anchor,
                         content_len,
                         mention_uri.name().into(),
@@ -1488,8 +1500,14 @@ impl MessageEditor {
                         .spawn(async move |_cx| confirm_task.await.map_err(|e| e.to_string()))
                         .shared();
 
-                    mention_set.update(cx, |mention_set, _| {
-                        mention_set.insert_mention(crease_id, mention_uri, mention_task);
+                    mention_set.update(cx, |mention_set, cx| {
+                        mention_set.insert_mention(
+                            crease_id,
+                            mention_uri,
+                            mention_task,
+                            crease_entity,
+                            cx,
+                        );
                     });
                 })
             })
@@ -1744,7 +1762,7 @@ impl MessageEditor {
         for (range, mention_uri, mention) in mentions {
             let adjusted_start = insertion_start + range.start;
             let anchor = snapshot.anchor_before(MultiBufferOffset(adjusted_start));
-            let Some((crease_id, tx)) = insert_crease_for_mention(
+            let Some((crease_id, tx, crease_entity)) = insert_crease_for_mention(
                 snapshot.anchor_to_buffer_anchor(anchor).unwrap().0,
                 range.end - range.start,
                 mention_uri.name().into(),
@@ -1761,11 +1779,13 @@ impl MessageEditor {
             };
             drop(tx);
 
-            self.mention_set.update(cx, |mention_set, _cx| {
+            self.mention_set.update(cx, |mention_set, cx| {
                 mention_set.insert_mention(
                     crease_id,
                     mention_uri.clone(),
                     Task::ready(Ok(mention)).shared(),
+                    crease_entity,
+                    cx,
                 )
             });
         }
@@ -4349,7 +4369,7 @@ mod tests {
                     "line 3\nline 4\n".to_string(),
                 ),
             ] {
-                let Some((crease_id, tx)) = insert_crease_for_mention(
+                let Some((crease_id, tx, _crease_entity)) = insert_crease_for_mention(
                     snapshot
                         .anchor_to_buffer_anchor(
                             snapshot.anchor_before(MultiBufferOffset(range.start)),
@@ -4371,7 +4391,7 @@ mod tests {
                 };
                 drop(tx);
 
-                message_editor.mention_set.update(cx, |mention_set, _cx| {
+                message_editor.mention_set.update(cx, |mention_set, cx| {
                     mention_set.insert_mention(
                         crease_id,
                         uri,
@@ -4380,6 +4400,8 @@ mod tests {
                             tracked_buffers: Vec::new(),
                         }))
                         .shared(),
+                        None,
+                        cx,
                     );
                 });
             }
@@ -4508,7 +4530,7 @@ mod tests {
                     "line 3\nline 4\n".to_string(),
                 ),
             ] {
-                let Some((crease_id, tx)) = insert_crease_for_mention(
+                let Some((crease_id, tx, _crease_entity)) = insert_crease_for_mention(
                     snapshot
                         .anchor_to_buffer_anchor(
                             snapshot.anchor_before(MultiBufferOffset(range.start)),
@@ -4530,7 +4552,7 @@ mod tests {
                 };
                 drop(tx);
 
-                message_editor.mention_set.update(cx, |mention_set, _cx| {
+                message_editor.mention_set.update(cx, |mention_set, cx| {
                     mention_set.insert_mention(
                         crease_id,
                         uri,
@@ -4539,6 +4561,8 @@ mod tests {
                             tracked_buffers: Vec::new(),
                         }))
                         .shared(),
+                        None,
+                        cx,
                     );
                 });
             }

From 7dcd422a7350cfe0b1fe3e8f2244a07cc74c752f Mon Sep 17 00:00:00 2001
From: Vlad Ionescu <Vlaaaaaaad@users.noreply.github.com>
Date: Mon, 18 May 2026 20:15:04 +0300
Subject: [PATCH 009/105] opencode: Model updates (#57076)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

**TL;DR**: clearer docs + models cleanup.

----

**Docs**:
- as per the discussion in
https://github.com/zed-industries/zed/issues/56869, added a note to the
docs highlighting that temporary models should be configured using
Custom Models. Adding a whole example felt redundant considering the
full example is literally 2 rows below.


**Model updates**:
- **Ring 2.6 1T Free**: removed
- **GLM 5 and GLM 5.1**: different settings based on subscription —
[131k](https://github.com/anomalyco/models.dev/blob/8e710e19eabbfa464764afe54d67585cbee9f4d8/providers/opencode/models/glm-5.1.toml#L22)
[output](https://github.com/anomalyco/models.dev/blob/8e710e19eabbfa464764afe54d67585cbee9f4d8/providers/opencode/models/glm-5.toml#L22)
on OpenCode but
[32k](https://github.com/anomalyco/models.dev/blob/8e710e19eabbfa464764afe54d67585cbee9f4d8/providers/opencode-go/models/glm-5.1.toml#L22)
[output](https://github.com/anomalyco/models.dev/blob/8e710e19eabbfa464764afe54d67585cbee9f4d8/providers/opencode-go/models/glm-5.toml#L22)
on OpenCode Go
- **MiniMax M2.5**: different settings based on subscription — [131k
output on
OpenCode](https://github.com/anomalyco/models.dev/blob/8e710e19eabbfa464764afe54d67585cbee9f4d8/providers/opencode/models/minimax-m2.5.toml#L22)
and [65k on OpenCode
Go](https://github.com/anomalyco/models.dev/blob/8e710e19eabbfa464764afe54d67585cbee9f4d8/providers/opencode-go/models/minimax-m2.5.toml#L19)
- **Nemotron 3 Super Free**: enabled interleaved reasoning as per
[docs](https://github.com/anomalyco/models.dev/blob/8e710e19eabbfa464764afe54d67585cbee9f4d8/providers/opencode/models/nemotron-3-super-free.toml#L13).
Ran some quick tests and confirmed everything seems to work fine
(_"rename this variable. add a simple function. remove the function.
tell me a joke"_)
- **GPT 5.3 Codex Spark**: removed image support as per
[docs](https://github.com/anomalyco/models.dev/blob/dev/providers/opencode/models/gpt-5.3-codex-spark.toml#L23-L25)

The [docs say GLM 5 in OpenCode Zen has a deprecation date of May
14](https://opencode.ai/docs/zen/#deprecated-models) but that seems to
still be active and is [not marked as deprecated on
models.dev](https://github.com/anomalyco/models.dev/blob/8e710e19eabbfa464764afe54d67585cbee9f4d8/providers/opencode/models/glm-5.toml)
so I didn't remove it yet 🤷

----

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [ ] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Closes https://github.com/zed-industries/zed/issues/56869

Release Notes:
- OpenCode: updated models (removed Ring 2.6 1T Free, enabled
interleaved reasoning for Nemotron 3 Super Free, deleted incorrect image
support for GPT 5.3 Codex Spark, and updated token counts for MiniMax
M2.5, GLM 5, and GLM 5.1)
- OpenCode Free: clearer docs for temporary free models
---
 .../language_models/src/provider/opencode.rs  | 12 +++--
 crates/opencode/src/opencode.rs               | 54 +++++++++++--------
 docs/src/ai/llm-providers.md                  |  2 +
 3 files changed, 42 insertions(+), 26 deletions(-)

diff --git a/crates/language_models/src/provider/opencode.rs b/crates/language_models/src/provider/opencode.rs
index 1d77c59f5d9..8179713a6a7 100644
--- a/crates/language_models/src/provider/opencode.rs
+++ b/crates/language_models/src/provider/opencode.rs
@@ -602,11 +602,11 @@ impl LanguageModel for OpenCodeLanguageModel {
     }
 
     fn max_token_count(&self) -> u64 {
-        self.model.max_token_count()
+        self.model.max_token_count(self.subscription)
     }
 
     fn max_output_tokens(&self) -> Option<u64> {
-        self.model.max_output_tokens()
+        self.model.max_output_tokens(self.subscription)
     }
 
     fn stream_completion(
@@ -646,7 +646,9 @@ impl LanguageModel for OpenCodeLanguageModel {
                     request,
                     self.model.id().to_string(),
                     1.0,
-                    self.model.max_output_tokens().unwrap_or(8192),
+                    self.model
+                        .max_output_tokens(self.subscription)
+                        .unwrap_or(8192),
                     mode,
                     anthropic::completion::AnthropicPromptCacheMode::Automatic,
                 );
@@ -671,7 +673,7 @@ impl LanguageModel for OpenCodeLanguageModel {
                     self.model.id(),
                     false,
                     false,
-                    self.model.max_output_tokens(),
+                    self.model.max_output_tokens(self.subscription),
                     reasoning_effort,
                     self.model.interleaved_reasoning(),
                 );
@@ -692,7 +694,7 @@ impl LanguageModel for OpenCodeLanguageModel {
                     self.model.id(),
                     false,
                     false,
-                    self.model.max_output_tokens(),
+                    self.model.max_output_tokens(self.subscription),
                     None,
                     supports_none_reasoning_effort,
                 );
diff --git a/crates/opencode/src/opencode.rs b/crates/opencode/src/opencode.rs
index 0e235bf7166..c4919f1759c 100644
--- a/crates/opencode/src/opencode.rs
+++ b/crates/opencode/src/opencode.rs
@@ -141,8 +141,6 @@ pub enum Model {
     MimoV2_5,
     #[serde(rename = "big-pickle")]
     BigPickle,
-    #[serde(rename = "ring-2.6-1t-free")]
-    Ring2_6_1TFree,
     #[serde(rename = "nemotron-3-super-free")]
     Nemotron3SuperFree,
     #[serde(rename = "qwen3.5-plus")]
@@ -204,10 +202,9 @@ impl Model {
             | Self::DeepSeekV4Flash => &[OpenCodeSubscription::Go],
 
             // Free models
-            Self::MiniMaxM2_5Free
-            | Self::Nemotron3SuperFree
-            | Self::BigPickle
-            | Self::Ring2_6_1TFree => &[OpenCodeSubscription::Free],
+            Self::MiniMaxM2_5Free | Self::Nemotron3SuperFree | Self::BigPickle => {
+                &[OpenCodeSubscription::Free]
+            }
 
             // Custom models get their subscription from settings, not from here
             Self::Custom { .. } => &[],
@@ -263,7 +260,6 @@ impl Model {
             Self::Qwen3_5Plus => "qwen3.5-plus",
             Self::Qwen3_6Plus => "qwen3.6-plus",
             Self::BigPickle => "big-pickle",
-            Self::Ring2_6_1TFree => "ring-2.6-1t-free",
             Self::Nemotron3SuperFree => "nemotron-3-super-free",
 
             Self::Custom { name, .. } => name,
@@ -316,7 +312,6 @@ impl Model {
             Self::Qwen3_5Plus => "Qwen3.5 Plus",
             Self::Qwen3_6Plus => "Qwen3.6 Plus",
             Self::BigPickle => "Big Pickle",
-            Self::Ring2_6_1TFree => "Ring 2.6 1T Free",
             Self::Nemotron3SuperFree => "Nemotron 3 Super Free",
 
             Self::Custom {
@@ -378,7 +373,6 @@ impl Model {
             | Self::DeepSeekV4Pro
             | Self::DeepSeekV4Flash
             | Self::BigPickle
-            | Self::Ring2_6_1TFree
             | Self::Nemotron3SuperFree => ApiProtocol::OpenAiChat,
 
             Self::Custom { protocol, .. } => *protocol,
@@ -395,8 +389,8 @@ impl Model {
             | Self::MimoV2_5Pro
             | Self::Glm5
             | Self::Glm5_1
-            | Self::BigPickle
-            | Self::Ring2_6_1TFree => true,
+            | Self::Nemotron3SuperFree
+            | Self::BigPickle => true,
 
             Self::Custom {
                 interleaved_reasoning,
@@ -407,7 +401,7 @@ impl Model {
         }
     }
 
-    pub fn max_token_count(&self) -> u64 {
+    pub fn max_token_count(&self, subscription: OpenCodeSubscription) -> u64 {
         match self {
             // Anthropic models
             Self::ClaudeOpus4_7 => 1_000_000,
@@ -436,13 +430,18 @@ impl Model {
             // OpenAI-compatible models
             Self::MiniMaxM2_7 => 204_800,
             Self::MiniMaxM2_5 | Self::MiniMaxM2_5Free => 204_800,
-            Self::Glm5 | Self::Glm5_1 => 202_725,
+            Self::Glm5 | Self::Glm5_1 => {
+                if subscription == OpenCodeSubscription::Go {
+                    202_752
+                } else {
+                    204_800
+                }
+            }
             Self::KimiK2_6 | Self::KimiK2_5 => 262_144,
             Self::MimoV2_5Pro => 1_048_576,
             Self::MimoV2_5 => 1_000_000,
             Self::Qwen3_5Plus | Self::Qwen3_6Plus => 262_144,
             Self::BigPickle => 200_000,
-            Self::Ring2_6_1TFree => 262_000,
             Self::Nemotron3SuperFree => 204_800,
             Self::DeepSeekV4Pro | Self::DeepSeekV4Flash => 1_000_000,
 
@@ -450,7 +449,7 @@ impl Model {
         }
     }
 
-    pub fn max_output_tokens(&self) -> Option<u64> {
+    pub fn max_output_tokens(&self, subscription: OpenCodeSubscription) -> Option<u64> {
         match self {
             // Anthropic models
             Self::ClaudeOpus4_7 | Self::ClaudeOpus4_6 => Some(128_000),
@@ -485,10 +484,22 @@ impl Model {
 
             // OpenAI-compatible models
             Self::MiniMaxM2_7 => Some(131_072),
-            Self::MiniMaxM2_5 | Self::MiniMaxM2_5Free => Some(131_072),
-            Self::Glm5 | Self::Glm5_1 => Some(32_768),
+            Self::MiniMaxM2_5Free => Some(131_072),
+            Self::MiniMaxM2_5 => {
+                if subscription == OpenCodeSubscription::Go {
+                    Some(65_536)
+                } else {
+                    Some(131_072)
+                }
+            }
+            Self::Glm5 | Self::Glm5_1 => {
+                if subscription == OpenCodeSubscription::Go {
+                    Some(32_768)
+                } else {
+                    Some(131_072)
+                }
+            }
             Self::BigPickle => Some(128_000),
-            Self::Ring2_6_1TFree => Some(66_000),
             Self::KimiK2_6 | Self::KimiK2_5 => Some(65_536),
             Self::Qwen3_5Plus | Self::Qwen3_6Plus => Some(65_536),
             Self::DeepSeekV4Pro | Self::DeepSeekV4Flash => Some(384_000),
@@ -525,7 +536,6 @@ impl Model {
             | Self::Gpt5_4Mini
             | Self::Gpt5_4Nano
             | Self::Gpt5_3Codex
-            | Self::Gpt5_3Spark
             | Self::Gpt5_2
             | Self::Gpt5_2Codex
             | Self::Gpt5_1
@@ -536,6 +546,9 @@ impl Model {
             | Self::Gpt5Codex
             | Self::Gpt5Nano => true,
 
+            // OpenAI models without image support
+            Self::Gpt5_3Spark => false,
+
             // Google models support images
             Self::Gemini3_1Pro | Self::Gemini3Flash => true,
 
@@ -556,7 +569,6 @@ impl Model {
             | Self::DeepSeekV4Pro
             | Self::DeepSeekV4Flash
             | Self::BigPickle
-            | Self::Ring2_6_1TFree
             | Self::Nemotron3SuperFree => false,
 
             Self::Custom { protocol, .. } => matches!(
@@ -571,7 +583,7 @@ impl Model {
 
     pub fn supported_reasoning_effort_levels(&self) -> Option<Vec<ReasoningEffort>> {
         match self {
-            Self::Ring2_6_1TFree | Self::MimoV2_5Pro | Self::MimoV2_5 => Some(vec![
+            Self::MimoV2_5Pro | Self::MimoV2_5 => Some(vec![
                 ReasoningEffort::Low,
                 ReasoningEffort::Medium,
                 ReasoningEffort::High,
diff --git a/docs/src/ai/llm-providers.md b/docs/src/ai/llm-providers.md
index 3a8455a327c..3c08a960da8 100644
--- a/docs/src/ai/llm-providers.md
+++ b/docs/src/ai/llm-providers.md
@@ -656,6 +656,8 @@ By default, models from all subscription types are shown. Optionally, you can hi
 }
 ```
 
+**Note:** Zed only bundles configuration for long-term OpenCode Free models! Free models that are only available for a limited time are not included in Zed. To use such models, create a Custom Model using the configuration settings published on [the OpenCode website](https://opencode.ai/docs/zen#pricing) and on [models.dev](https://github.com/anomalyco/models.dev/tree/dev/providers/opencode/models).
+
 #### Custom Models {#opencode-custom-models}
 
 The Zed agent comes pre-configured with OpenCode models. If you wish to use newer models or models with custom endpoints, you can do so by adding the following to your Zed settings file ([how to edit](../configuring-zed.md#settings-files)):

From 7a37888f7bc93146ee435ca404dc4b6923ddb71a Mon Sep 17 00:00:00 2001
From: Neel <neel@zed.dev>
Date: Mon, 18 May 2026 19:02:51 +0100
Subject: [PATCH 010/105] editor: Add action to toggle all diff hunks (#56421)

Release Notes:

- Added action to toggle all diff hunks
---
 crates/editor/src/actions.rs |  3 +++
 crates/editor/src/element.rs |  1 +
 crates/editor/src/git.rs     | 13 +++++++++++++
 3 files changed, 17 insertions(+)

diff --git a/crates/editor/src/actions.rs b/crates/editor/src/actions.rs
index 01f52e7064d..03557c029f1 100644
--- a/crates/editor/src/actions.rs
+++ b/crates/editor/src/actions.rs
@@ -501,6 +501,9 @@ actions!(
         ExpandAllDiffHunks,
         /// Collapses all diff hunks in the editor.
         CollapseAllDiffHunks,
+        /// Toggles all diff hunks in the editor. Collapses all hunks if any are
+        /// currently expanded, otherwise expands all hunks.
+        ToggleAllDiffHunks,
         /// Expands macros recursively at cursor position.
         ExpandMacroRecursively,
         /// Finds the next match in the search.
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index e04161b6c8a..97380794178 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -468,6 +468,7 @@ impl EditorElement {
         register_action(editor, window, Editor::unstage_and_next);
         register_action(editor, window, Editor::expand_all_diff_hunks);
         register_action(editor, window, Editor::collapse_all_diff_hunks);
+        register_action(editor, window, Editor::toggle_all_diff_hunks);
         register_action(editor, window, Editor::toggle_review_comments_expanded);
         register_action(editor, window, Editor::submit_diff_review_comment_action);
         register_action(editor, window, Editor::edit_review_comment);
diff --git a/crates/editor/src/git.rs b/crates/editor/src/git.rs
index 2571c0b2022..16b1bc4daee 100644
--- a/crates/editor/src/git.rs
+++ b/crates/editor/src/git.rs
@@ -759,6 +759,19 @@ impl Editor {
         });
     }
 
+    pub fn toggle_all_diff_hunks(
+        &mut self,
+        _: &ToggleAllDiffHunks,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if self.has_any_expanded_diff_hunks(cx) {
+            self.collapse_all_diff_hunks(&CollapseAllDiffHunks, window, cx);
+        } else {
+            self.expand_all_diff_hunks(&ExpandAllDiffHunks, window, cx);
+        }
+    }
+
     pub(super) fn toggle_selected_diff_hunks(
         &mut self,
         _: &ToggleSelectedDiffHunks,

From c3951af24fff4942fdd941d814f1d8c84e25b9e3 Mon Sep 17 00:00:00 2001
From: Ben Brandt <benjamin.j.brandt@gmail.com>
Date: Mon, 18 May 2026 20:27:54 +0200
Subject: [PATCH 011/105] acp: Support additional session directories (#57051)

Still behind a feature flag for now for testing with various agents.

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Release Notes:

- N/A
---
 Cargo.lock                                    |   8 +-
 Cargo.toml                                    |   2 +-
 crates/acp_thread/src/connection.rs           |  19 +
 crates/agent_servers/src/acp.rs               | 489 +++++++++++++++++-
 .../src/conversation_view/thread_view.rs      |   9 +
 5 files changed, 496 insertions(+), 31 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index cfe21109573..3631fa41c4e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -224,9 +224,9 @@ dependencies = [
 
 [[package]]
 name = "agent-client-protocol"
-version = "0.12.0"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1084cabbc2b00d353bad7e54750b0ef0f0bba9204c5884240c83a628704db86c"
+checksum = "4361ba6627e51de955b10f3c77fb9eb959c85191a236c1c2c84e32f4ff240faf"
 dependencies = [
  "agent-client-protocol-derive",
  "agent-client-protocol-schema",
@@ -259,9 +259,9 @@ dependencies = [
 
 [[package]]
 name = "agent-client-protocol-schema"
-version = "0.13.1"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2984583e634f3f4d479b585aaa76de4a633255dcdf2be6489c6a8486f758af04"
+checksum = "b957d8391ac3933e2a940446171c508d2b8ffc386d8fa7d0b9c936a2575b463e"
 dependencies = [
  "anyhow",
  "derive_more",
diff --git a/Cargo.toml b/Cargo.toml
index 7303d4ebe0a..e6d883245ab 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -500,7 +500,7 @@ ztracing_macro = { path = "crates/ztracing_macro" }
 # External crates
 #
 
-agent-client-protocol = { version = "=0.12.0", features = ["unstable"] }
+agent-client-protocol = { version = "=0.12.1", features = ["unstable"] }
 aho-corasick = "1.1"
 alacritty_terminal = { git = "https://github.com/zed-industries/alacritty", rev = "9d9640d4" }
 any_vec = "0.14"
diff --git a/crates/acp_thread/src/connection.rs b/crates/acp_thread/src/connection.rs
index 87c8ccf65c1..f58d8a581b8 100644
--- a/crates/acp_thread/src/connection.rs
+++ b/crates/acp_thread/src/connection.rs
@@ -115,6 +115,11 @@ pub trait AgentConnection {
         self.supports_load_session() || self.supports_resume_session()
     }
 
+    /// Whether this agent supports additional session directories.
+    fn supports_session_additional_directories(&self, _cx: &App) -> bool {
+        false
+    }
+
     fn auth_methods(&self) -> &[acp::AuthMethod];
 
     fn terminal_auth_task(
@@ -702,6 +707,7 @@ mod test_support {
         permission_requests: HashMap<acp::ToolCallId, PermissionOptions>,
         next_prompt_updates: Arc<Mutex<Vec<acp::SessionUpdate>>>,
         supports_load_session: bool,
+        supports_session_additional_directories: bool,
         agent_id: AgentId,
         telemetry_id: SharedString,
     }
@@ -724,6 +730,7 @@ mod test_support {
                 permission_requests: HashMap::default(),
                 sessions: Arc::default(),
                 supports_load_session: false,
+                supports_session_additional_directories: false,
                 agent_id: AgentId::new("stub"),
                 telemetry_id: "stub".into(),
             }
@@ -746,6 +753,14 @@ mod test_support {
             self
         }
 
+        pub fn with_supports_session_additional_directories(
+            mut self,
+            supports_session_additional_directories: bool,
+        ) -> Self {
+            self.supports_session_additional_directories = supports_session_additional_directories;
+            self
+        }
+
         pub fn with_agent_id(mut self, agent_id: AgentId) -> Self {
             self.agent_id = agent_id;
             self
@@ -863,6 +878,10 @@ mod test_support {
             self.supports_load_session
         }
 
+        fn supports_session_additional_directories(&self, _cx: &App) -> bool {
+            self.supports_session_additional_directories
+        }
+
         fn load_session(
             self: Rc<Self>,
             session_id: acp::SessionId,
diff --git a/crates/agent_servers/src/acp.rs b/crates/agent_servers/src/acp.rs
index b3328790a5d..ff5519b7240 100644
--- a/crates/agent_servers/src/acp.rs
+++ b/crates/agent_servers/src/acp.rs
@@ -9,7 +9,7 @@ use agent_client_protocol::{
 };
 use anyhow::anyhow;
 use async_channel;
-use collections::HashMap;
+use collections::{HashMap, HashSet};
 use feature_flags::{AcpBetaFeatureFlag, FeatureFlagAppExt as _};
 use futures::channel::mpsc;
 use futures::future::Shared;
@@ -509,6 +509,7 @@ impl AgentSessionList for AcpSessionList {
         cx: &mut App,
     ) -> Task<Result<AgentSessionListResponse>> {
         let conn = self.connection.clone();
+        let include_additional_directories = cx.has_flag::<AcpBetaFeatureFlag>();
         cx.foreground_executor().spawn(async move {
             let acp_request = acp::ListSessionsRequest::new()
                 .cwd(request.cwd)
@@ -522,7 +523,14 @@ impl AgentSessionList for AcpSessionList {
                     .into_iter()
                     .map(|s| AgentSessionInfo {
                         session_id: s.session_id,
-                        work_dirs: Some(PathList::new(&[s.cwd])),
+                        work_dirs: Some(work_dirs_from_session_info(
+                            s.cwd,
+                            if include_additional_directories {
+                                s.additional_directories
+                            } else {
+                                vec![]
+                            },
+                        )),
                         title: s.title.map(Into::into),
                         updated_at: s.updated_at.and_then(|date_str| {
                             chrono::DateTime::parse_from_rfc3339(&date_str)
@@ -1053,6 +1061,15 @@ impl AcpConnection {
         }
     }
 
+    fn session_directories_from_work_dirs(
+        &self,
+        work_dirs: &PathList,
+        cx: &App,
+    ) -> Result<SessionDirectories> {
+        let supports_additional_directories = self.supports_session_additional_directories(cx);
+        session_directories_from_work_dirs(work_dirs, supports_additional_directories)
+    }
+
     fn open_or_create_session(
         self: Rc<Self>,
         session_id: acp::SessionId,
@@ -1062,7 +1079,7 @@ impl AcpConnection {
         rpc_call: impl FnOnce(
             ConnectionTo<Agent>,
             acp::SessionId,
-            PathBuf,
+            SessionDirectories,
         )
             -> futures::future::LocalBoxFuture<'static, Result<SessionConfigResponse>>
         + 'static,
@@ -1089,9 +1106,9 @@ impl AcpConnection {
             }
         }
 
-        // TODO: remove this once ACP supports multiple working directories
-        let Some(cwd) = work_dirs.ordered_paths().next().cloned() else {
-            return Task::ready(Err(anyhow!("Working directory cannot be empty")));
+        let directories = match self.session_directories_from_work_dirs(&work_dirs, cx) {
+            Ok(directories) => directories,
+            Err(error) => return Task::ready(Err(error)),
         };
 
         let shared_task = cx
@@ -1133,7 +1150,9 @@ impl AcpConnection {
                     );
 
                     let response =
-                        match rpc_call(this.connection.clone(), session_id.clone(), cwd).await {
+                        match rpc_call(this.connection.clone(), session_id.clone(), directories)
+                            .await
+                        {
                             Ok(response) => response,
                             Err(err) => {
                                 this.sessions.borrow_mut().remove(&session_id);
@@ -1288,6 +1307,77 @@ impl AcpConnection {
     }
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+struct SessionDirectories {
+    cwd: PathBuf,
+    additional_directories: Vec<PathBuf>,
+}
+
+impl SessionDirectories {
+    fn into_new_session_request(self, mcp_servers: Vec<acp::McpServer>) -> acp::NewSessionRequest {
+        acp::NewSessionRequest::new(self.cwd)
+            .additional_directories(self.additional_directories)
+            .mcp_servers(mcp_servers)
+    }
+
+    fn into_load_session_request(
+        self,
+        session_id: acp::SessionId,
+        mcp_servers: Vec<acp::McpServer>,
+    ) -> acp::LoadSessionRequest {
+        acp::LoadSessionRequest::new(session_id, self.cwd)
+            .additional_directories(self.additional_directories)
+            .mcp_servers(mcp_servers)
+    }
+
+    fn into_resume_session_request(
+        self,
+        session_id: acp::SessionId,
+        mcp_servers: Vec<acp::McpServer>,
+    ) -> acp::ResumeSessionRequest {
+        acp::ResumeSessionRequest::new(session_id, self.cwd)
+            .additional_directories(self.additional_directories)
+            .mcp_servers(mcp_servers)
+    }
+}
+
+fn session_directories_from_work_dirs(
+    work_dirs: &PathList,
+    supports_additional_directories: bool,
+) -> Result<SessionDirectories> {
+    let mut ordered_paths = work_dirs.ordered_paths();
+    let cwd = ordered_paths
+        .next()
+        .cloned()
+        .ok_or_else(|| anyhow!("Working directory cannot be empty"))?;
+    let additional_directories = if supports_additional_directories {
+        ordered_paths.cloned().collect()
+    } else {
+        Vec::new()
+    };
+
+    Ok(SessionDirectories {
+        cwd,
+        additional_directories,
+    })
+}
+
+fn work_dirs_from_session_info(cwd: PathBuf, additional_directories: Vec<PathBuf>) -> PathList {
+    let mut seen_paths = HashSet::default();
+    let mut paths = Vec::with_capacity(1 + additional_directories.len());
+
+    seen_paths.insert(cwd.clone());
+    paths.push(cwd);
+
+    for path in additional_directories {
+        if seen_paths.insert(path.clone()) {
+            paths.push(path);
+        }
+    }
+
+    PathList::new(&paths)
+}
+
 fn emit_load_error_to_all_sessions(
     sessions: &Rc<RefCell<HashMap<acp::SessionId, AcpSession>>>,
     error: LoadError,
@@ -1385,17 +1475,18 @@ impl AgentConnection for AcpConnection {
         work_dirs: PathList,
         cx: &mut App,
     ) -> Task<Result<Entity<AcpThread>>> {
-        // TODO: remove this once ACP supports multiple working directories
-        let Some(cwd) = work_dirs.ordered_paths().next().cloned() else {
-            return Task::ready(Err(anyhow!("Working directory cannot be empty")));
+        let directories = match self.session_directories_from_work_dirs(&work_dirs, cx) {
+            Ok(directories) => directories,
+            Err(error) => return Task::ready(Err(error)),
         };
         let name = self.id.0.clone();
         let mcp_servers = mcp_servers_for_project(&project, cx);
 
         cx.spawn(async move |cx| {
             let response = into_foreground_future(
-                self.connection
-                    .send_request(acp::NewSessionRequest::new(cwd.clone()).mcp_servers(mcp_servers)),
+                self.connection.send_request(
+                    directories.into_new_session_request(mcp_servers),
+                ),
             )
             .await
             .map_err(map_acp_error)?;
@@ -1550,6 +1641,15 @@ impl AgentConnection for AcpConnection {
             .is_some()
     }
 
+    fn supports_session_additional_directories(&self, cx: &App) -> bool {
+        cx.has_flag::<AcpBetaFeatureFlag>()
+            && self
+                .agent_capabilities
+                .session_capabilities
+                .additional_directories
+                .is_some()
+    }
+
     fn load_session(
         self: Rc<Self>,
         session_id: acp::SessionId,
@@ -1570,14 +1670,11 @@ impl AgentConnection for AcpConnection {
             project,
             work_dirs,
             title,
-            move |connection, session_id, cwd| {
+            move |connection, session_id, directories| {
                 Box::pin(async move {
-                    let response = into_foreground_future(
-                        connection.send_request(
-                            acp::LoadSessionRequest::new(session_id.clone(), cwd)
-                                .mcp_servers(mcp_servers),
-                        ),
-                    )
+                    let response = into_foreground_future(connection.send_request(
+                        directories.into_load_session_request(session_id.clone(), mcp_servers),
+                    ))
                     .await
                     .map_err(map_acp_error)?;
                     Ok(SessionConfigResponse {
@@ -1616,14 +1713,11 @@ impl AgentConnection for AcpConnection {
             project,
             work_dirs,
             title,
-            move |connection, session_id, cwd| {
+            move |connection, session_id, directories| {
                 Box::pin(async move {
-                    let response = into_foreground_future(
-                        connection.send_request(
-                            acp::ResumeSessionRequest::new(session_id.clone(), cwd)
-                                .mcp_servers(mcp_servers),
-                        ),
-                    )
+                    let response = into_foreground_future(connection.send_request(
+                        directories.into_resume_session_request(session_id.clone(), mcp_servers),
+                    ))
                     .await
                     .map_err(map_acp_error)?;
                     Ok(SessionConfigResponse {
@@ -2107,6 +2201,10 @@ pub mod test_support {
             self.inner.supports_resume_session()
         }
 
+        fn supports_session_additional_directories(&self, cx: &App) -> bool {
+            self.inner.supports_session_additional_directories(cx)
+        }
+
         fn resume_session(
             self: Rc<Self>,
             session_id: acp::SessionId,
@@ -2557,6 +2655,345 @@ mod tests {
         );
     }
 
+    #[test]
+    fn session_directories_use_ordered_paths_when_supported() {
+        let work_dirs = PathList::new(&[
+            std::path::PathBuf::from("/workspace-b"),
+            std::path::PathBuf::from("/workspace-a"),
+            std::path::PathBuf::from("/workspace-c"),
+        ]);
+
+        let directories =
+            session_directories_from_work_dirs(&work_dirs, true).expect("work dirs should convert");
+
+        assert_eq!(
+            directories,
+            SessionDirectories {
+                cwd: std::path::PathBuf::from("/workspace-b"),
+                additional_directories: vec![
+                    std::path::PathBuf::from("/workspace-a"),
+                    std::path::PathBuf::from("/workspace-c")
+                ],
+            }
+        );
+
+        let session_id = acp::SessionId::new("session-1");
+        let new_session_request = directories.clone().into_new_session_request(Vec::new());
+        let load_session_request = directories
+            .clone()
+            .into_load_session_request(session_id.clone(), Vec::new());
+        let resume_session_request =
+            directories.into_resume_session_request(session_id, Vec::new());
+
+        assert_eq!(
+            new_session_request.cwd,
+            std::path::PathBuf::from("/workspace-b")
+        );
+        assert_eq!(
+            new_session_request.additional_directories,
+            vec![
+                std::path::PathBuf::from("/workspace-a"),
+                std::path::PathBuf::from("/workspace-c")
+            ]
+        );
+        assert_eq!(
+            load_session_request.additional_directories,
+            new_session_request.additional_directories
+        );
+        assert_eq!(
+            resume_session_request.additional_directories,
+            new_session_request.additional_directories
+        );
+    }
+
+    #[test]
+    fn session_directories_drop_additional_paths_when_unsupported() {
+        let work_dirs = PathList::new(&[
+            std::path::PathBuf::from("/workspace-b"),
+            std::path::PathBuf::from("/workspace-a"),
+        ]);
+
+        let directories = session_directories_from_work_dirs(&work_dirs, false)
+            .expect("work dirs should convert");
+
+        assert_eq!(
+            directories,
+            SessionDirectories {
+                cwd: std::path::PathBuf::from("/workspace-b"),
+                additional_directories: Vec::new(),
+            }
+        );
+    }
+
+    #[test]
+    fn session_info_work_dirs_preserve_cwd_then_additional_directories() {
+        let work_dirs = work_dirs_from_session_info(
+            std::path::PathBuf::from("/workspace-b"),
+            vec![
+                std::path::PathBuf::from("/workspace-a"),
+                std::path::PathBuf::from("/workspace-c"),
+            ],
+        );
+
+        assert_eq!(
+            work_dirs.ordered_paths().cloned().collect::<Vec<_>>(),
+            vec![
+                std::path::PathBuf::from("/workspace-b"),
+                std::path::PathBuf::from("/workspace-a"),
+                std::path::PathBuf::from("/workspace-c"),
+            ]
+        );
+    }
+
+    #[test]
+    fn session_info_work_dirs_deduplicate_cwd_and_additional_directories() {
+        let work_dirs = work_dirs_from_session_info(
+            std::path::PathBuf::from("/workspace-b"),
+            vec![
+                std::path::PathBuf::from("/workspace-a"),
+                std::path::PathBuf::from("/workspace-b"),
+                std::path::PathBuf::from("/workspace-a"),
+                std::path::PathBuf::from("/workspace-c"),
+            ],
+        );
+
+        assert_eq!(
+            work_dirs.ordered_paths().cloned().collect::<Vec<_>>(),
+            vec![
+                std::path::PathBuf::from("/workspace-b"),
+                std::path::PathBuf::from("/workspace-a"),
+                std::path::PathBuf::from("/workspace-c"),
+            ]
+        );
+    }
+
+    #[gpui::test]
+    async fn session_list_includes_additional_directories_in_work_dirs_when_beta_enabled(
+        cx: &mut gpui::TestAppContext,
+    ) {
+        cx.update(|cx| set_acp_beta_override(cx, "on"));
+        let connection = connect_session_list_test_agent(
+            vec![
+                acp::SessionInfo::new("session-1", "/workspace-b").additional_directories(vec![
+                    std::path::PathBuf::from("/workspace-a"),
+                    std::path::PathBuf::from("/workspace-b"),
+                    std::path::PathBuf::from("/workspace-a"),
+                    std::path::PathBuf::from("/workspace-c"),
+                ]),
+            ],
+            cx,
+        )
+        .await;
+        let session_list = AcpSessionList::new(connection, false);
+
+        let response = cx
+            .update(|cx| session_list.list_sessions(AgentSessionListRequest::default(), cx))
+            .await
+            .expect("session list should load");
+        let session = response
+            .sessions
+            .first()
+            .expect("session list should include the returned session");
+        let work_dirs = session
+            .work_dirs
+            .as_ref()
+            .expect("session should include work dirs");
+
+        assert_eq!(
+            work_dirs.ordered_paths().cloned().collect::<Vec<_>>(),
+            vec![
+                std::path::PathBuf::from("/workspace-b"),
+                std::path::PathBuf::from("/workspace-a"),
+                std::path::PathBuf::from("/workspace-c"),
+            ]
+        );
+    }
+
+    #[gpui::test]
+    async fn session_list_excludes_additional_directories_in_work_dirs_when_beta_disabled(
+        cx: &mut gpui::TestAppContext,
+    ) {
+        cx.update(|cx| set_acp_beta_override(cx, "off"));
+
+        let connection = connect_session_list_test_agent(
+            vec![
+                acp::SessionInfo::new("session-1", "/workspace-b").additional_directories(vec![
+                    std::path::PathBuf::from("/workspace-a"),
+                    std::path::PathBuf::from("/workspace-c"),
+                ]),
+            ],
+            cx,
+        )
+        .await;
+        let session_list = AcpSessionList::new(connection, false);
+
+        let response = cx
+            .update(|cx| session_list.list_sessions(AgentSessionListRequest::default(), cx))
+            .await
+            .expect("session list should load");
+        let session = response
+            .sessions
+            .first()
+            .expect("session list should include the returned session");
+        let work_dirs = session
+            .work_dirs
+            .as_ref()
+            .expect("session should include work dirs");
+
+        assert_eq!(
+            work_dirs.ordered_paths().cloned().collect::<Vec<_>>(),
+            vec![std::path::PathBuf::from("/workspace-b")]
+        );
+    }
+
+    fn set_acp_beta_override(cx: &mut App, value: &str) {
+        let store = settings::SettingsStore::test(cx);
+        cx.set_global(store);
+        settings::SettingsStore::update_global(cx, |store, _| {
+            store.register_setting::<feature_flags::FeatureFlagsSettings>();
+        });
+        feature_flags::FeatureFlagStore::init(cx);
+
+        let value = value.to_string();
+        settings::SettingsStore::update_global(cx, |store, cx| {
+            store.update_user_settings(cx, |content| {
+                content
+                    .feature_flags
+                    .get_or_insert_default()
+                    .insert(AcpBetaFeatureFlag::NAME.to_string(), value);
+            });
+        });
+    }
+
+    async fn connect_session_list_test_agent(
+        sessions: Vec<acp::SessionInfo>,
+        cx: &mut gpui::TestAppContext,
+    ) -> ConnectionTo<Agent> {
+        let (client_transport, agent_transport) = agent_client_protocol::Channel::duplex();
+        let sessions = Arc::new(sessions);
+
+        cx.background_spawn(
+            Agent
+                .builder()
+                .name("list-test-agent")
+                .on_receive_request(
+                    {
+                        let sessions = sessions.clone();
+                        async move |_request: acp::ListSessionsRequest, responder, _cx| {
+                            responder.respond(acp::ListSessionsResponse::new((*sessions).clone()))
+                        }
+                    },
+                    agent_client_protocol::on_receive_request!(),
+                )
+                .connect_to(agent_transport),
+        )
+        .detach();
+
+        let (connection_tx, connection_rx) = futures::channel::oneshot::channel();
+        cx.background_spawn(Client.builder().name("list-test-client").connect_with(
+            client_transport,
+            move |connection: ConnectionTo<Agent>| async move {
+                connection_tx.send(connection).ok();
+                futures::future::pending::<Result<(), acp::Error>>().await
+            },
+        ))
+        .detach();
+
+        connection_rx
+            .await
+            .expect("failed to receive ACP connection")
+    }
+
+    #[gpui::test]
+    async fn additional_directories_support_requires_beta_flag_and_agent_capability(
+        cx: &mut gpui::TestAppContext,
+    ) {
+        cx.update(|cx| {
+            let store = settings::SettingsStore::test(cx);
+            cx.set_global(store);
+            settings::SettingsStore::update_global(cx, |store, _| {
+                store.register_setting::<feature_flags::FeatureFlagsSettings>();
+            });
+            feature_flags::FeatureFlagStore::init(cx);
+        });
+
+        let fs = fs::FakeFs::new(cx.executor());
+        fs.insert_tree("/", serde_json::json!({ "a": {}, "b": {} }))
+            .await;
+        let project = project::Project::test(fs, [std::path::Path::new("/a")], cx).await;
+        let mut harness = test_support::connect_fake_acp_connection(project, cx).await;
+        cx.update(|cx| {
+            settings::SettingsStore::update_global(cx, |store, _| {
+                store.register_setting::<feature_flags::FeatureFlagsSettings>();
+            });
+            feature_flags::FeatureFlagStore::init(cx);
+        });
+
+        let work_dirs = PathList::new(&[
+            std::path::PathBuf::from("/workspace-b"),
+            std::path::PathBuf::from("/workspace-a"),
+        ]);
+
+        let missing_capability = cx
+            .update(|cx| {
+                harness
+                    .connection
+                    .session_directories_from_work_dirs(&work_dirs, cx)
+            })
+            .expect("work dirs should convert");
+        assert!(missing_capability.additional_directories.is_empty());
+
+        Rc::get_mut(&mut harness.connection)
+            .expect("test harness should own the only ACP connection handle")
+            .agent_capabilities
+            .session_capabilities
+            .additional_directories = Some(acp::SessionAdditionalDirectoriesCapabilities::new());
+
+        cx.update(|cx| {
+            settings::SettingsStore::update_global(cx, |store, cx| {
+                store.update_user_settings(cx, |content| {
+                    content
+                        .feature_flags
+                        .get_or_insert_default()
+                        .insert("acp-beta".to_string(), "off".to_string());
+                });
+            });
+        });
+        let disabled = cx
+            .update(|cx| {
+                harness
+                    .connection
+                    .session_directories_from_work_dirs(&work_dirs, cx)
+            })
+            .expect("work dirs should convert");
+        assert!(disabled.additional_directories.is_empty());
+
+        cx.update(|cx| {
+            settings::SettingsStore::update_global(cx, |store, cx| {
+                store.update_user_settings(cx, |content| {
+                    content
+                        .feature_flags
+                        .get_or_insert_default()
+                        .insert("acp-beta".to_string(), "on".to_string());
+                });
+            });
+        });
+        let enabled = cx
+            .update(|cx| {
+                harness
+                    .connection
+                    .session_directories_from_work_dirs(&work_dirs, cx)
+            })
+            .expect("work dirs should convert");
+        assert_eq!(
+            enabled,
+            SessionDirectories {
+                cwd: std::path::PathBuf::from("/workspace-b"),
+                additional_directories: vec![std::path::PathBuf::from("/workspace-a")],
+            }
+        );
+    }
+
     #[gpui::test]
     async fn session_delete_support_requires_beta_flag_and_capability(
         cx: &mut gpui::TestAppContext,
diff --git a/crates/agent_ui/src/conversation_view/thread_view.rs b/crates/agent_ui/src/conversation_view/thread_view.rs
index 3bd2fb6326b..9d78baf826c 100644
--- a/crates/agent_ui/src/conversation_view/thread_view.rs
+++ b/crates/agent_ui/src/conversation_view/thread_view.rs
@@ -8826,6 +8826,15 @@ impl ThreadView {
             return None;
         }
 
+        if self
+            .thread
+            .read(cx)
+            .connection()
+            .supports_session_additional_directories(cx)
+        {
+            return None;
+        }
+
         let project = self.project.upgrade()?;
         let worktree_count = project.read(cx).visible_worktrees(cx).count();
         if worktree_count <= 1 {

From 10fc0fb5271e2f41d32cb11fcbe2c65ca6d67654 Mon Sep 17 00:00:00 2001
From: Ben Brandt <benjamin.j.brandt@gmail.com>
Date: Mon, 18 May 2026 21:07:09 +0200
Subject: [PATCH 012/105] Update wgpu to 29.0.3 (#57086)

Updates our fork to the latest v29 branch. Still waiting on a backport
to get upstreamed so we can go back to the main crate.

Release Notes:

- N/A
---
 Cargo.lock | 37 +++++++++++++++++++------------------
 Cargo.toml |  2 +-
 2 files changed, 20 insertions(+), 19 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 3631fa41c4e..b46f8c8f265 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11004,8 +11004,8 @@ checksum = "e5ce46fe64a9d73be07dcbe690a38ce1b293be448fd8ce1e6c1b8062c9f72c6a"
 
 [[package]]
 name = "naga"
-version = "29.0.0"
-source = "git+https://github.com/zed-industries/wgpu.git?branch=v29#a466bc382ea747f8e1ac810efdb6dcd49a514575"
+version = "29.0.3"
+source = "git+https://github.com/zed-industries/wgpu.git?rev=357a0c56e0070480ad9daea5d2eaa83150b79e88#357a0c56e0070480ad9daea5d2eaa83150b79e88"
 dependencies = [
  "arrayvec",
  "bit-set 0.9.1",
@@ -20559,8 +20559,8 @@ checksum = "a751b3277700db47d3e574514de2eced5e54dc8a5436a3bf7a0b248b2cee16f3"
 
 [[package]]
 name = "wgpu"
-version = "29.0.0"
-source = "git+https://github.com/zed-industries/wgpu.git?branch=v29#a466bc382ea747f8e1ac810efdb6dcd49a514575"
+version = "29.0.3"
+source = "git+https://github.com/zed-industries/wgpu.git?rev=357a0c56e0070480ad9daea5d2eaa83150b79e88#357a0c56e0070480ad9daea5d2eaa83150b79e88"
 dependencies = [
  "arrayvec",
  "bitflags 2.10.0",
@@ -20588,8 +20588,8 @@ dependencies = [
 
 [[package]]
 name = "wgpu-core"
-version = "29.0.0"
-source = "git+https://github.com/zed-industries/wgpu.git?branch=v29#a466bc382ea747f8e1ac810efdb6dcd49a514575"
+version = "29.0.3"
+source = "git+https://github.com/zed-industries/wgpu.git?rev=357a0c56e0070480ad9daea5d2eaa83150b79e88#357a0c56e0070480ad9daea5d2eaa83150b79e88"
 dependencies = [
  "arrayvec",
  "bit-set 0.9.1",
@@ -20620,32 +20620,32 @@ dependencies = [
 
 [[package]]
 name = "wgpu-core-deps-apple"
-version = "29.0.0"
-source = "git+https://github.com/zed-industries/wgpu.git?branch=v29#a466bc382ea747f8e1ac810efdb6dcd49a514575"
+version = "29.0.3"
+source = "git+https://github.com/zed-industries/wgpu.git?rev=357a0c56e0070480ad9daea5d2eaa83150b79e88#357a0c56e0070480ad9daea5d2eaa83150b79e88"
 dependencies = [
  "wgpu-hal",
 ]
 
 [[package]]
 name = "wgpu-core-deps-emscripten"
-version = "29.0.0"
-source = "git+https://github.com/zed-industries/wgpu.git?branch=v29#a466bc382ea747f8e1ac810efdb6dcd49a514575"
+version = "29.0.3"
+source = "git+https://github.com/zed-industries/wgpu.git?rev=357a0c56e0070480ad9daea5d2eaa83150b79e88#357a0c56e0070480ad9daea5d2eaa83150b79e88"
 dependencies = [
  "wgpu-hal",
 ]
 
 [[package]]
 name = "wgpu-core-deps-windows-linux-android"
-version = "29.0.0"
-source = "git+https://github.com/zed-industries/wgpu.git?branch=v29#a466bc382ea747f8e1ac810efdb6dcd49a514575"
+version = "29.0.3"
+source = "git+https://github.com/zed-industries/wgpu.git?rev=357a0c56e0070480ad9daea5d2eaa83150b79e88#357a0c56e0070480ad9daea5d2eaa83150b79e88"
 dependencies = [
  "wgpu-hal",
 ]
 
 [[package]]
 name = "wgpu-hal"
-version = "29.0.0"
-source = "git+https://github.com/zed-industries/wgpu.git?branch=v29#a466bc382ea747f8e1ac810efdb6dcd49a514575"
+version = "29.0.3"
+source = "git+https://github.com/zed-industries/wgpu.git?rev=357a0c56e0070480ad9daea5d2eaa83150b79e88#357a0c56e0070480ad9daea5d2eaa83150b79e88"
 dependencies = [
  "android_system_properties",
  "arrayvec",
@@ -20692,12 +20692,13 @@ dependencies = [
  "wgpu-types",
  "windows 0.62.2",
  "windows-core 0.62.2",
+ "windows-result 0.4.1",
 ]
 
 [[package]]
 name = "wgpu-naga-bridge"
-version = "29.0.0"
-source = "git+https://github.com/zed-industries/wgpu.git?branch=v29#a466bc382ea747f8e1ac810efdb6dcd49a514575"
+version = "29.0.3"
+source = "git+https://github.com/zed-industries/wgpu.git?rev=357a0c56e0070480ad9daea5d2eaa83150b79e88#357a0c56e0070480ad9daea5d2eaa83150b79e88"
 dependencies = [
  "naga",
  "wgpu-types",
@@ -20705,8 +20706,8 @@ dependencies = [
 
 [[package]]
 name = "wgpu-types"
-version = "29.0.0"
-source = "git+https://github.com/zed-industries/wgpu.git?branch=v29#a466bc382ea747f8e1ac810efdb6dcd49a514575"
+version = "29.0.3"
+source = "git+https://github.com/zed-industries/wgpu.git?rev=357a0c56e0070480ad9daea5d2eaa83150b79e88#357a0c56e0070480ad9daea5d2eaa83150b79e88"
 dependencies = [
  "bitflags 2.10.0",
  "bytemuck",
diff --git a/Cargo.toml b/Cargo.toml
index e6d883245ab..7e113da2f7e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -812,7 +812,7 @@ which = "6.0.0"
 wasm-bindgen = "0.2.120"
 web-time = "1.1.0"
 webrtc-sys = "0.3.23"
-wgpu = { git = "https://github.com/zed-industries/wgpu.git", branch = "v29" }
+wgpu = { git = "https://github.com/zed-industries/wgpu.git", rev = "357a0c56e0070480ad9daea5d2eaa83150b79e88" }
 windows-core = "0.61"
 yaml-rust2 = "0.8"
 yawc = "0.2.5"

From 2a00db06ce6d01089bfafd207b6348078e980df9 Mon Sep 17 00:00:00 2001
From: Ben Brandt <benjamin.j.brandt@gmail.com>
Date: Mon, 18 May 2026 23:10:06 +0200
Subject: [PATCH 013/105] node_runtime: Respect npm release-age filters for
 managed npm installs (#56957)

Zed-managed npm installers were resolving a concrete latest version with
`npm info` and then installing `package@version`. That is brittle when
users
configure npm release-age filtering via `before` or `min-release-age`:
npm's
installer applies those rules during resolution, but our pinned install
target
could disagree with it, and therefore fail to install.

This changes managed npm installs to install `package@latest` and let
npm apply
its own resolver and user config. The local latest-version lookup
remains as a
best-effort cache freshness check, not as the exact install target.

Exact extension API installs remain unchanged because extensions
explicitly
request a package and version. If we want to revisit that we can.

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Closes #53611

Release Notes:

- Fixed npm-backed tool installs to better respect npm release-age
filters.
---
 Cargo.lock                              |   1 +
 crates/copilot/src/copilot.rs           |   5 +-
 crates/languages/src/bash.rs            |  10 +-
 crates/languages/src/css.rs             |  10 +-
 crates/languages/src/json.rs            |  10 +-
 crates/languages/src/python.rs          |  22 +-
 crates/languages/src/tailwind.rs        |  10 +-
 crates/languages/src/tailwindcss.rs     |  10 +-
 crates/languages/src/typescript.rs      |  11 +-
 crates/languages/src/vtsls.rs           |  47 +++-
 crates/languages/src/yaml.rs            |  10 +-
 crates/node_runtime/Cargo.toml          |   1 +
 crates/node_runtime/src/node_runtime.rs | 345 +++++++++++++++++++++++-
 crates/project/src/debugger/session.rs  |   2 +-
 crates/project/src/prettier_store.rs    |  30 +--
 15 files changed, 405 insertions(+), 119 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index b46f8c8f265..51a1d750fa4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11178,6 +11178,7 @@ dependencies = [
  "async-std",
  "async-tar",
  "async-trait",
+ "chrono",
  "futures 0.3.32",
  "http_client",
  "log",
diff --git a/crates/copilot/src/copilot.rs b/crates/copilot/src/copilot.rs
index 4fa41fc8cb4..a48bf3c1a43 100644
--- a/crates/copilot/src/copilot.rs
+++ b/crates/copilot/src/copilot.rs
@@ -1413,10 +1413,7 @@ async fn get_copilot_lsp(fs: Arc<dyn Fs>, node_runtime: NodeRuntime) -> anyhow::
             .await;
     if should_install {
         node_runtime
-            .npm_install_packages(
-                paths::copilot_dir(),
-                &[(PACKAGE_NAME, &latest_version.to_string())],
-            )
+            .npm_install_latest_packages(paths::copilot_dir(), &[PACKAGE_NAME])
             .await?;
     }
 
diff --git a/crates/languages/src/bash.rs b/crates/languages/src/bash.rs
index 438090e2aa9..2f550e87c7f 100644
--- a/crates/languages/src/bash.rs
+++ b/crates/languages/src/bash.rs
@@ -141,7 +141,7 @@ impl LspInstaller for BashLspAdapter {
 
     fn fetch_server_binary(
         &self,
-        latest_version: Self::BinaryVersion,
+        _latest_version: Self::BinaryVersion,
         container_dir: std::path::PathBuf,
         delegate: &Arc<dyn LspAdapterDelegate>,
     ) -> impl Send + Future<Output = Result<lsp::LanguageServerBinary>> + use<> {
@@ -152,13 +152,9 @@ impl LspInstaller for BashLspAdapter {
             let server_path = container_dir
                 .join("node_modules")
                 .join(Self::NODE_MODULE_RELATIVE_SERVER_PATH);
-            let latest_version = latest_version.to_string();
 
-            node.npm_install_packages(
-                &container_dir,
-                &[(Self::PACKAGE_NAME, latest_version.as_str())],
-            )
-            .await?;
+            node.npm_install_latest_packages(&container_dir, &[Self::PACKAGE_NAME])
+                .await?;
 
             let env = delegate.shell_env().await;
             Ok(LanguageServerBinary {
diff --git a/crates/languages/src/css.rs b/crates/languages/src/css.rs
index dfa0bc9fd3d..4506481a17b 100644
--- a/crates/languages/src/css.rs
+++ b/crates/languages/src/css.rs
@@ -67,7 +67,7 @@ impl LspInstaller for CssLspAdapter {
 
     fn fetch_server_binary(
         &self,
-        latest_version: Self::BinaryVersion,
+        _latest_version: Self::BinaryVersion,
         container_dir: PathBuf,
         _: &Arc<dyn LspAdapterDelegate>,
     ) -> impl Send + Future<Output = Result<LanguageServerBinary>> + use<> {
@@ -75,13 +75,9 @@ impl LspInstaller for CssLspAdapter {
 
         async move {
             let server_path = container_dir.join(SERVER_PATH);
-            let latest_version = latest_version.to_string();
 
-            node.npm_install_packages(
-                &container_dir,
-                &[(Self::PACKAGE_NAME, latest_version.as_str())],
-            )
-            .await?;
+            node.npm_install_latest_packages(&container_dir, &[Self::PACKAGE_NAME])
+                .await?;
 
             Ok(LanguageServerBinary {
                 path: node.binary_path().await?,
diff --git a/crates/languages/src/json.rs b/crates/languages/src/json.rs
index 9cd6c1565ad..8389fd65f65 100644
--- a/crates/languages/src/json.rs
+++ b/crates/languages/src/json.rs
@@ -213,7 +213,7 @@ impl LspInstaller for JsonLspAdapter {
 
     fn fetch_server_binary(
         &self,
-        latest_version: Self::BinaryVersion,
+        _latest_version: Self::BinaryVersion,
         container_dir: PathBuf,
         _: &Arc<dyn LspAdapterDelegate>,
     ) -> impl Send + Future<Output = Result<LanguageServerBinary>> + use<> {
@@ -221,13 +221,9 @@ impl LspInstaller for JsonLspAdapter {
 
         async move {
             let server_path = container_dir.join(SERVER_PATH);
-            let latest_version = latest_version.to_string();
 
-            node.npm_install_packages(
-                &container_dir,
-                &[(Self::PACKAGE_NAME, latest_version.as_str())],
-            )
-            .await?;
+            node.npm_install_latest_packages(&container_dir, &[Self::PACKAGE_NAME])
+                .await?;
 
             Ok(LanguageServerBinary {
                 path: node.binary_path().await?,
diff --git a/crates/languages/src/python.rs b/crates/languages/src/python.rs
index 483430bd75d..5d2024d3b8d 100644
--- a/crates/languages/src/python.rs
+++ b/crates/languages/src/python.rs
@@ -786,7 +786,7 @@ impl LspInstaller for PyrightLspAdapter {
 
     fn fetch_server_binary(
         &self,
-        latest_version: Self::BinaryVersion,
+        _latest_version: Self::BinaryVersion,
         container_dir: PathBuf,
         delegate: &Arc<dyn LspAdapterDelegate>,
     ) -> impl Send + Future<Output = Result<LanguageServerBinary>> + use<> {
@@ -795,13 +795,8 @@ impl LspInstaller for PyrightLspAdapter {
 
         async move {
             let server_path = container_dir.join(Self::SERVER_PATH);
-            let latest_version = latest_version.to_string();
-
-            node.npm_install_packages(
-                &container_dir,
-                &[(Self::SERVER_NAME.as_ref(), latest_version.as_str())],
-            )
-            .await?;
+            node.npm_install_latest_packages(&container_dir, &[Self::SERVER_NAME.as_ref()])
+                .await?;
 
             let env = delegate.shell_env().await;
             Ok(LanguageServerBinary {
@@ -2252,7 +2247,7 @@ impl LspInstaller for BasedPyrightLspAdapter {
 
     fn fetch_server_binary(
         &self,
-        latest_version: Self::BinaryVersion,
+        _latest_version: Self::BinaryVersion,
         container_dir: PathBuf,
         delegate: &Arc<dyn LspAdapterDelegate>,
     ) -> impl Send + Future<Output = Result<LanguageServerBinary>> + use<> {
@@ -2261,13 +2256,8 @@ impl LspInstaller for BasedPyrightLspAdapter {
 
         async move {
             let server_path = container_dir.join(Self::SERVER_PATH);
-            let latest_version = latest_version.to_string();
-
-            node.npm_install_packages(
-                &container_dir,
-                &[(Self::SERVER_NAME.as_ref(), latest_version.as_str())],
-            )
-            .await?;
+            node.npm_install_latest_packages(&container_dir, &[Self::SERVER_NAME.as_ref()])
+                .await?;
 
             let env = delegate.shell_env().await;
             Ok(LanguageServerBinary {
diff --git a/crates/languages/src/tailwind.rs b/crates/languages/src/tailwind.rs
index 41fa248a935..6d4211b58c8 100644
--- a/crates/languages/src/tailwind.rs
+++ b/crates/languages/src/tailwind.rs
@@ -72,7 +72,7 @@ impl LspInstaller for TailwindLspAdapter {
 
     fn fetch_server_binary(
         &self,
-        latest_version: Self::BinaryVersion,
+        _latest_version: Self::BinaryVersion,
         container_dir: PathBuf,
         _: &Arc<dyn LspAdapterDelegate>,
     ) -> impl Send + Future<Output = Result<LanguageServerBinary>> + use<> {
@@ -80,13 +80,9 @@ impl LspInstaller for TailwindLspAdapter {
 
         async move {
             let server_path = container_dir.join(SERVER_PATH);
-            let latest_version = latest_version.to_string();
 
-            node.npm_install_packages(
-                &container_dir,
-                &[(Self::PACKAGE_NAME, latest_version.as_str())],
-            )
-            .await?;
+            node.npm_install_latest_packages(&container_dir, &[Self::PACKAGE_NAME])
+                .await?;
 
             Ok(LanguageServerBinary {
                 path: node.binary_path().await?,
diff --git a/crates/languages/src/tailwindcss.rs b/crates/languages/src/tailwindcss.rs
index dcc9e8bf4ef..0e9ac9af40f 100644
--- a/crates/languages/src/tailwindcss.rs
+++ b/crates/languages/src/tailwindcss.rs
@@ -68,7 +68,7 @@ impl LspInstaller for TailwindCssLspAdapter {
 
     fn fetch_server_binary(
         &self,
-        latest_version: Self::BinaryVersion,
+        _latest_version: Self::BinaryVersion,
         container_dir: PathBuf,
         _: &Arc<dyn LspAdapterDelegate>,
     ) -> impl Send + Future<Output = Result<LanguageServerBinary>> + use<> {
@@ -76,13 +76,9 @@ impl LspInstaller for TailwindCssLspAdapter {
 
         async move {
             let server_path = container_dir.join(SERVER_PATH);
-            let latest_version = latest_version.to_string();
 
-            node.npm_install_packages(
-                &container_dir,
-                &[(Self::PACKAGE_NAME, latest_version.as_str())],
-            )
-            .await?;
+            node.npm_install_latest_packages(&container_dir, &[Self::PACKAGE_NAME])
+                .await?;
 
             Ok(LanguageServerBinary {
                 path: node.binary_path().await?,
diff --git a/crates/languages/src/typescript.rs b/crates/languages/src/typescript.rs
index d6889d8cbb8..4d37898eca1 100644
--- a/crates/languages/src/typescript.rs
+++ b/crates/languages/src/typescript.rs
@@ -718,7 +718,7 @@ impl LspInstaller for TypeScriptLspAdapter {
 
     fn fetch_server_binary(
         &self,
-        latest_version: Self::BinaryVersion,
+        _latest_version: Self::BinaryVersion,
         container_dir: PathBuf,
         _: &Arc<dyn LspAdapterDelegate>,
     ) -> impl Send + Future<Output = Result<LanguageServerBinary>> + use<> {
@@ -726,15 +726,10 @@ impl LspInstaller for TypeScriptLspAdapter {
 
         async move {
             let server_path = container_dir.join(Self::NEW_SERVER_PATH);
-            let typescript_version = latest_version.typescript_version.to_string();
-            let server_version = latest_version.server_version.to_string();
 
-            node.npm_install_packages(
+            node.npm_install_latest_packages(
                 &container_dir,
-                &[
-                    (Self::PACKAGE_NAME, typescript_version.as_str()),
-                    (Self::SERVER_PACKAGE_NAME, server_version.as_str()),
-                ],
+                &[Self::PACKAGE_NAME, Self::SERVER_PACKAGE_NAME],
             )
             .await?;
 
diff --git a/crates/languages/src/vtsls.rs b/crates/languages/src/vtsls.rs
index 4bc4401ff30..c46ea39a4f1 100644
--- a/crates/languages/src/vtsls.rs
+++ b/crates/languages/src/vtsls.rs
@@ -126,7 +126,7 @@ impl LspInstaller for VtslsLspAdapter {
 
     fn fetch_server_binary(
         &self,
-        latest_version: Self::BinaryVersion,
+        _latest_version: Self::BinaryVersion,
         container_dir: PathBuf,
         _: &Arc<dyn LspAdapterDelegate>,
     ) -> impl Send + Future<Output = Result<LanguageServerBinary>> + use<> {
@@ -135,21 +135,44 @@ impl LspInstaller for VtslsLspAdapter {
         async move {
             let server_path = container_dir.join(Self::SERVER_PATH);
 
-            let typescript_version = latest_version.typescript_version.to_string();
-            let server_version = latest_version.server_version.to_string();
+            node.npm_install_latest_packages(
+                &container_dir,
+                &[Self::PACKAGE_NAME, Self::TYPESCRIPT_PACKAGE_NAME],
+            )
+            .await?;
 
-            let mut packages_to_install = Vec::new();
+            Ok(LanguageServerBinary {
+                path: node.binary_path().await?,
+                env: None,
+                arguments: typescript_server_binary_arguments(&server_path),
+            })
+        }
+    }
+
+    fn check_if_version_installed(
+        &self,
+        version: &Self::BinaryVersion,
+        container_dir: &PathBuf,
+        _: &Arc<dyn LspAdapterDelegate>,
+    ) -> impl Send + Future<Output = Option<LanguageServerBinary>> + use<> {
+        let node = self.node.clone();
+        let typescript_version = version.typescript_version.clone();
+        let server_version = version.server_version.clone();
+        let container_dir = container_dir.clone();
+
+        async move {
+            let server_path = container_dir.join(Self::SERVER_PATH);
 
             if node
                 .should_install_npm_package(
                     Self::PACKAGE_NAME,
                     &server_path,
                     &container_dir,
-                    VersionStrategy::Latest(&latest_version.server_version),
+                    VersionStrategy::Latest(&server_version),
                 )
                 .await
             {
-                packages_to_install.push((Self::PACKAGE_NAME, server_version.as_str()));
+                return None;
             }
 
             if node
@@ -157,19 +180,15 @@ impl LspInstaller for VtslsLspAdapter {
                     Self::TYPESCRIPT_PACKAGE_NAME,
                     &container_dir.join(Self::TYPESCRIPT_TSDK_PATH),
                     &container_dir,
-                    VersionStrategy::Latest(&latest_version.typescript_version),
+                    VersionStrategy::Latest(&typescript_version),
                 )
                 .await
             {
-                packages_to_install
-                    .push((Self::TYPESCRIPT_PACKAGE_NAME, typescript_version.as_str()));
+                return None;
             }
 
-            node.npm_install_packages(&container_dir, &packages_to_install)
-                .await?;
-
-            Ok(LanguageServerBinary {
-                path: node.binary_path().await?,
+            Some(LanguageServerBinary {
+                path: node.binary_path().await.ok()?,
                 env: None,
                 arguments: typescript_server_binary_arguments(&server_path),
             })
diff --git a/crates/languages/src/yaml.rs b/crates/languages/src/yaml.rs
index 22781acf25a..de9b11b03dc 100644
--- a/crates/languages/src/yaml.rs
+++ b/crates/languages/src/yaml.rs
@@ -68,7 +68,7 @@ impl LspInstaller for YamlLspAdapter {
 
     fn fetch_server_binary(
         &self,
-        latest_version: Self::BinaryVersion,
+        _latest_version: Self::BinaryVersion,
         container_dir: PathBuf,
         _: &Arc<dyn LspAdapterDelegate>,
     ) -> impl Send + Future<Output = Result<LanguageServerBinary>> + use<> {
@@ -76,13 +76,9 @@ impl LspInstaller for YamlLspAdapter {
 
         async move {
             let server_path = container_dir.join(SERVER_PATH);
-            let latest_version = latest_version.to_string();
 
-            node.npm_install_packages(
-                &container_dir,
-                &[(Self::PACKAGE_NAME, latest_version.as_str())],
-            )
-            .await?;
+            node.npm_install_latest_packages(&container_dir, &[Self::PACKAGE_NAME])
+                .await?;
 
             Ok(LanguageServerBinary {
                 path: node.binary_path().await?,
diff --git a/crates/node_runtime/Cargo.toml b/crates/node_runtime/Cargo.toml
index dfa40ad666e..25f7b2997e5 100644
--- a/crates/node_runtime/Cargo.toml
+++ b/crates/node_runtime/Cargo.toml
@@ -20,6 +20,7 @@ anyhow.workspace = true
 async-compression.workspace = true
 async-tar.workspace = true
 async-trait.workspace = true
+chrono.workspace = true
 futures.workspace = true
 http_client.workspace = true
 log.workspace = true
diff --git a/crates/node_runtime/src/node_runtime.rs b/crates/node_runtime/src/node_runtime.rs
index 9d4bfe9cffb..7ce29532644 100644
--- a/crates/node_runtime/src/node_runtime.rs
+++ b/crates/node_runtime/src/node_runtime.rs
@@ -1,6 +1,7 @@
 use anyhow::{Context as _, Result, anyhow, bail};
 use async_compression::futures::bufread::GzipDecoder;
 use async_tar::Archive;
+use chrono::{DateTime, Utc};
 use futures::{AsyncReadExt, FutureExt as _, channel::oneshot, future::Shared};
 use http_client::{Host, HttpClient, Url};
 use log::Level;
@@ -253,9 +254,8 @@ impl NodeRuntime {
 
     pub async fn npm_package_latest_version(&self, name: &str) -> Result<Version> {
         let http = self.0.lock().await.http.clone();
-        let output = self
-            .instance()
-            .await
+        let instance = self.instance().await;
+        let output = instance
             .run_npm_subcommand(
                 None,
                 http.proxy(),
@@ -273,11 +273,18 @@ impl NodeRuntime {
             )
             .await?;
 
-        let mut info: NpmInfo = serde_json::from_slice(&output.stdout)?;
-        info.dist_tags
-            .latest
-            .or_else(|| info.versions.pop())
-            .with_context(|| format!("no version found for npm package {name}"))
+        let info: NpmInfo = serde_json::from_slice(&output.stdout)?;
+        let before = npm_config_before(instance.as_ref(), http.proxy())
+            .await
+            .context("getting npm before config")
+            .log_err()
+            .flatten();
+        let latest_dist_tag = info.dist_tags.latest.clone();
+        let selected_version = select_npm_package_version(name, info, before.as_deref())?;
+        log::debug!(
+            "selected latest npm package version package={name:?} before={before:?} dist_tag_latest={latest_dist_tag:?} selected={selected_version}"
+        );
+        Ok(selected_version)
     }
 
     pub async fn npm_install_packages(
@@ -289,6 +296,11 @@ impl NodeRuntime {
             return Ok(());
         }
 
+        log::debug!(
+            "installing npm packages directory={} packages={packages:?}",
+            directory.display()
+        );
+
         let packages: Vec<_> = packages
             .iter()
             .map(|(name, version)| format!("{name}@{version}"))
@@ -314,6 +326,23 @@ impl NodeRuntime {
         Ok(())
     }
 
+    pub async fn npm_install_latest_packages(
+        &self,
+        directory: &Path,
+        package_names: &[&str],
+    ) -> Result<()> {
+        // Let npm apply user config such as `before` and `min-release-age` during resolution.
+        log::debug!(
+            "installing latest npm packages directory={} packages={package_names:?}",
+            directory.display()
+        );
+        let packages = package_names
+            .iter()
+            .map(|package_name| (*package_name, "latest"))
+            .collect::<Vec<_>>();
+        self.npm_install_packages(directory, &packages).await
+    }
+
     pub async fn should_install_npm_package(
         &self,
         package_name: &str,
@@ -325,6 +354,10 @@ impl NodeRuntime {
         // or in the instances where we fail to parse package.json data,
         // we attempt to install the package.
         if fs::metadata(local_executable_path).await.is_err() {
+            log::debug!(
+                "npm package cache miss package={package_name:?} reason=missing-executable executable={}",
+                local_executable_path.display()
+            );
             return true;
         }
 
@@ -334,13 +367,33 @@ impl NodeRuntime {
             .log_err()
             .flatten()
         else {
+            log::debug!(
+                "npm package cache miss package={package_name:?} reason=missing-installed-version package_dir={}",
+                local_package_directory.display()
+            );
             return true;
         };
 
-        match version_strategy {
-            VersionStrategy::Pin(pinned_version) => &installed_version != pinned_version,
-            VersionStrategy::Latest(latest_version) => &installed_version < latest_version,
-        }
+        let version_strategy_label = match &version_strategy {
+            VersionStrategy::Pin(version) => format!("pin:{version}"),
+            VersionStrategy::Latest(version) => format!("latest:{version}"),
+        };
+        let should_install =
+            should_install_npm_package_version(&installed_version, version_strategy);
+        log::debug!(
+            "npm package cache check package={package_name:?} installed={installed_version} strategy={version_strategy_label} should_install={should_install}"
+        );
+        should_install
+    }
+}
+
+fn should_install_npm_package_version(
+    installed_version: &Version,
+    version_strategy: VersionStrategy<'_>,
+) -> bool {
+    match version_strategy {
+        VersionStrategy::Pin(pinned_version) => installed_version != pinned_version,
+        VersionStrategy::Latest(latest_version) => installed_version < latest_version,
     }
 }
 
@@ -355,6 +408,8 @@ pub struct NpmInfo {
     #[serde(default)]
     dist_tags: NpmInfoDistTags,
     versions: Vec<Version>,
+    #[serde(default)]
+    time: HashMap<String, String>,
 }
 
 #[derive(Debug, Deserialize, Default)]
@@ -362,6 +417,95 @@ pub struct NpmInfoDistTags {
     latest: Option<Version>,
 }
 
+#[derive(Debug, Deserialize)]
+struct NpmConfig {
+    #[serde(default)]
+    before: Option<String>,
+}
+
+async fn npm_config_before(
+    node_runtime: &dyn NodeRuntimeTrait,
+    proxy: Option<&Url>,
+) -> Result<Option<String>> {
+    // `npm config get before` renders Date values for display. The JSON config output keeps the
+    // computed cutoff in the same ISO format used by `npm info --json` release times.
+    let output = node_runtime
+        .run_npm_subcommand(None, proxy, "config", &["list", "--json"])
+        .await?;
+    let config: NpmConfig = serde_json::from_slice(&output.stdout)?;
+    Ok(config
+        .before
+        .filter(|before| !before.trim().is_empty() && before != "null"))
+}
+
+fn select_npm_package_version(
+    package_name: &str,
+    mut info: NpmInfo,
+    before: Option<&str>,
+) -> Result<Version> {
+    if let Some(before) = before
+        && !info.time.is_empty()
+    {
+        let before_timestamp = DateTime::parse_from_rfc3339(before)
+            .with_context(|| format!("parsing npm before config timestamp {before:?}"))?
+            .with_timezone(&Utc);
+        let latest_version = info.dist_tags.latest.as_ref();
+
+        if let Some(version) = latest_version
+            && npm_version_was_published_before(version, &info.time, &before_timestamp)?
+        {
+            return Ok(version.clone());
+        }
+
+        for version in info.versions.iter().rev() {
+            if is_allowed_npm_version_before(
+                version,
+                latest_version,
+                &info.time,
+                &before_timestamp,
+            )? {
+                return Ok(version.clone());
+            }
+        }
+
+        bail!("no version found for npm package {package_name} before {before}");
+    }
+
+    info.dist_tags
+        .latest
+        .or_else(|| info.versions.pop())
+        .with_context(|| format!("no version found for npm package {package_name}"))
+}
+
+fn is_allowed_npm_version_before(
+    version: &Version,
+    latest_version: Option<&Version>,
+    published_at_by_version: &HashMap<String, String>,
+    before: &DateTime<Utc>,
+) -> Result<bool> {
+    if !version.pre.is_empty()
+        || latest_version.is_some_and(|latest_version| version > latest_version)
+    {
+        return Ok(false);
+    }
+
+    npm_version_was_published_before(version, published_at_by_version, before)
+}
+
+fn npm_version_was_published_before(
+    version: &Version,
+    published_at_by_version: &HashMap<String, String>,
+    before: &DateTime<Utc>,
+) -> Result<bool> {
+    let Some(published_at) = published_at_by_version.get(&version.to_string()) else {
+        return Ok(false);
+    };
+    let published_at = DateTime::parse_from_rfc3339(published_at)
+        .with_context(|| format!("parsing npm release timestamp for version {version}"))?
+        .with_timezone(&Utc);
+    Ok(&published_at <= before)
+}
+
 #[async_trait::async_trait]
 trait NodeRuntimeTrait: Send + Sync {
     fn boxed_clone(&self) -> Box<dyn NodeRuntimeTrait>;
@@ -936,9 +1080,14 @@ fn npm_command_env(node_binary: Option<&Path>) -> HashMap<String, String> {
 mod tests {
     use std::path::Path;
 
+    use anyhow::{Result, bail};
     use http_client::Url;
+    use semver::Version;
 
-    use super::{build_npm_command_args, proxy_argument};
+    use super::{
+        NpmInfo, VersionStrategy, build_npm_command_args, proxy_argument,
+        select_npm_package_version, should_install_npm_package_version,
+    };
 
     // Map localhost to 127.0.0.1
     // NodeRuntime without environment information can not parse `localhost` correctly.
@@ -1021,4 +1170,174 @@ mod tests {
             ]
         );
     }
+
+    #[test]
+    fn test_latest_version_strategy_accepts_newer_installed_versions() -> Result<()> {
+        let target_version = Version::parse("2.0.0")?;
+
+        assert!(!should_install_npm_package_version(
+            &Version::parse("2.0.0")?,
+            VersionStrategy::Latest(&target_version)
+        ));
+        assert!(should_install_npm_package_version(
+            &Version::parse("1.0.0")?,
+            VersionStrategy::Latest(&target_version)
+        ));
+        assert!(!should_install_npm_package_version(
+            &Version::parse("3.0.0")?,
+            VersionStrategy::Latest(&target_version)
+        ));
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_select_npm_package_version_uses_dist_tag_without_before() -> Result<()> {
+        let info: NpmInfo = serde_json::from_str(
+            r#"{
+                "dist-tags": { "latest": "3.0.0" },
+                "versions": ["1.0.0", "2.0.0", "3.0.0"],
+                "time": {
+                    "1.0.0": "2024-01-01T00:00:00.000Z",
+                    "2.0.0": "2024-02-01T00:00:00.000Z",
+                    "3.0.0": "2024-03-01T00:00:00.000Z"
+                }
+            }"#,
+        )?;
+
+        assert_eq!(
+            select_npm_package_version("test-package", info, None)?,
+            Version::parse("3.0.0")?
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_select_npm_package_version_uses_latest_before_npm_before_config() -> Result<()> {
+        let info: NpmInfo = serde_json::from_str(
+            r#"{
+                "dist-tags": { "latest": "3.0.0" },
+                "versions": ["1.0.0", "2.0.0", "3.0.0"],
+                "time": {
+                    "1.0.0": "2024-01-01T00:00:00.000Z",
+                    "2.0.0": "2024-02-01T00:00:00.000Z",
+                    "3.0.0": "2024-03-01T00:00:00.000Z"
+                }
+            }"#,
+        )?;
+
+        assert_eq!(
+            select_npm_package_version("test-package", info, Some("2024-02-15T00:00:00.000Z"))?,
+            Version::parse("2.0.0")?
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_select_npm_package_version_keeps_allowed_latest_dist_tag() -> Result<()> {
+        let info: NpmInfo = serde_json::from_str(
+            r#"{
+                "dist-tags": { "latest": "2.0.0" },
+                "versions": ["1.0.0", "2.0.0", "3.0.0"],
+                "time": {
+                    "1.0.0": "2024-01-01T00:00:00.000Z",
+                    "2.0.0": "2024-02-01T00:00:00.000Z",
+                    "3.0.0": "2024-03-01T00:00:00.000Z"
+                }
+            }"#,
+        )?;
+
+        assert_eq!(
+            select_npm_package_version("test-package", info, Some("2024-02-15T00:00:00.000Z"))?,
+            Version::parse("2.0.0")?
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_select_npm_package_version_keeps_allowed_prerelease_latest_dist_tag() -> Result<()> {
+        let info: NpmInfo = serde_json::from_str(
+            r#"{
+                "dist-tags": { "latest": "2.0.0-beta.1" },
+                "versions": ["1.0.0", "2.0.0-beta.1"],
+                "time": {
+                    "1.0.0": "2024-01-01T00:00:00.000Z",
+                    "2.0.0-beta.1": "2024-02-01T00:00:00.000Z"
+                }
+            }"#,
+        )?;
+
+        assert_eq!(
+            select_npm_package_version("test-package", info, Some("2024-02-15T00:00:00.000Z"))?,
+            Version::parse("2.0.0-beta.1")?
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_select_npm_package_version_ignores_prereleases_before_cutoff() -> Result<()> {
+        let info: NpmInfo = serde_json::from_str(
+            r#"{
+                "dist-tags": { "latest": "2.0.0" },
+                "versions": ["1.0.0", "2.0.0-beta.1", "2.0.0"],
+                "time": {
+                    "1.0.0": "2024-01-01T00:00:00.000Z",
+                    "2.0.0-beta.1": "2024-02-01T00:00:00.000Z",
+                    "2.0.0": "2024-03-01T00:00:00.000Z"
+                }
+            }"#,
+        )?;
+
+        assert_eq!(
+            select_npm_package_version("test-package", info, Some("2024-02-15T00:00:00.000Z"))?,
+            Version::parse("1.0.0")?
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_select_npm_package_version_ignores_versions_above_latest_dist_tag() -> Result<()> {
+        let info: NpmInfo = serde_json::from_str(
+            r#"{
+                "dist-tags": { "latest": "2.0.0" },
+                "versions": ["1.0.0", "2.0.0", "3.0.0"],
+                "time": {
+                    "1.0.0": "2024-01-01T00:00:00.000Z",
+                    "2.0.0": "2024-03-01T00:00:00.000Z",
+                    "3.0.0": "2024-02-01T00:00:00.000Z"
+                }
+            }"#,
+        )?;
+
+        assert_eq!(
+            select_npm_package_version("test-package", info, Some("2024-02-15T00:00:00.000Z"))?,
+            Version::parse("1.0.0")?
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_select_npm_package_version_errors_when_no_version_matches_before() -> Result<()> {
+        let info: NpmInfo = serde_json::from_str(
+            r#"{
+                "dist-tags": { "latest": "2.0.0" },
+                "versions": ["1.0.0", "2.0.0"],
+                "time": {
+                    "1.0.0": "2024-01-01T00:00:00.000Z",
+                    "2.0.0": "2024-02-01T00:00:00.000Z"
+                }
+            }"#,
+        )?;
+
+        let Err(error) =
+            select_npm_package_version("test-package", info, Some("2023-12-01T00:00:00.000Z"))
+        else {
+            bail!("expected cutoff to reject all package versions");
+        };
+        assert_eq!(
+            error.to_string(),
+            "no version found for npm package test-package before 2023-12-01T00:00:00.000Z"
+        );
+        Ok(())
+    }
 }
diff --git a/crates/project/src/debugger/session.rs b/crates/project/src/debugger/session.rs
index 39578eaf8f0..fc5f56395cc 100644
--- a/crates/project/src/debugger/session.rs
+++ b/crates/project/src/debugger/session.rs
@@ -3145,7 +3145,7 @@ async fn get_or_install_companion(node: NodeRuntime, cx: &mut AsyncApp) -> Resul
 
     async fn install_latest_version(dir: PathBuf, node: NodeRuntime) -> Result<PathBuf> {
         let temp_dir = tempfile::tempdir().context("creating temporary directory")?;
-        node.npm_install_packages(temp_dir.path(), &[(PACKAGE_NAME, "latest")])
+        node.npm_install_latest_packages(temp_dir.path(), &[PACKAGE_NAME])
             .await
             .context("installing latest companion package")?;
         let version = node
diff --git a/crates/project/src/prettier_store.rs b/crates/project/src/prettier_store.rs
index faa2cca7986..8d9399dce64 100644
--- a/crates/project/src/prettier_store.rs
+++ b/crates/project/src/prettier_store.rs
@@ -930,23 +930,11 @@ async fn install_prettier_packages(
     plugins_to_install: HashSet<Arc<str>>,
     node: NodeRuntime,
 ) -> anyhow::Result<()> {
-    let packages_to_versions = future::try_join_all(
-        plugins_to_install
-            .iter()
-            .chain(Some(&"prettier".into()))
-            .map(|package_name| async {
-                let returned_package_name = package_name.to_string();
-                let latest_version = node
-                    .npm_package_latest_version(package_name)
-                    .await
-                    .with_context(|| {
-                        format!("fetching latest npm version for package {returned_package_name}")
-                    })?;
-                anyhow::Ok((returned_package_name, latest_version.to_string()))
-            }),
-    )
-    .await
-    .context("fetching latest npm versions")?;
+    let packages_to_install = plugins_to_install
+        .iter()
+        .map(|package_name| package_name.to_string())
+        .chain(Some("prettier".to_string()))
+        .collect::<Vec<_>>();
 
     let default_prettier_dir = default_prettier_dir().as_path();
     match fs.metadata(default_prettier_dir).await.with_context(|| {
@@ -962,12 +950,12 @@ async fn install_prettier_packages(
             .with_context(|| format!("creating default prettier dir {default_prettier_dir:?}"))?,
     }
 
-    log::info!("Installing default prettier and plugins: {packages_to_versions:?}");
-    let borrowed_packages = packages_to_versions
+    log::info!("Installing default prettier and plugins: {packages_to_install:?}");
+    let borrowed_packages = packages_to_install
         .iter()
-        .map(|(package, version)| (package.as_str(), version.as_str()))
+        .map(|package_name| package_name.as_str())
         .collect::<Vec<_>>();
-    node.npm_install_packages(default_prettier_dir, &borrowed_packages)
+    node.npm_install_latest_packages(default_prettier_dir, &borrowed_packages)
         .await
         .context("fetching formatter packages")?;
     anyhow::Ok(())

From 9abb73ee326118a7bf8afcd524acbb660e97bd50 Mon Sep 17 00:00:00 2001
From: Gepcel <gepcelway@gmail.com>
Date: Tue, 19 May 2026 06:32:04 +0800
Subject: [PATCH 014/105] xtask: Fix `setup-webrtc` config overwrite refusal
 and Windows path format (#57058)

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] No unsafe blocks
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Closes #57057

Release Notes:

- N/A

---------

Co-authored-by: zed-zippy[bot] <234243425+zed-zippy[bot]@users.noreply.github.com>
---
 tooling/xtask/src/tasks/setup_webrtc.rs | 52 ++++++++++++++++---------
 1 file changed, 34 insertions(+), 18 deletions(-)

diff --git a/tooling/xtask/src/tasks/setup_webrtc.rs b/tooling/xtask/src/tasks/setup_webrtc.rs
index 756a3767838..5dbf5bcaa96 100644
--- a/tooling/xtask/src/tasks/setup_webrtc.rs
+++ b/tooling/xtask/src/tasks/setup_webrtc.rs
@@ -219,31 +219,47 @@ fn update_cargo_config(webrtc_path: &Path) -> Result<()> {
         .or_else(|| std::env::var_os("USERPROFILE"))
         .context("could not determine home directory")?;
     let config_path = PathBuf::from(home).join(".cargo").join("config.toml");
-    if config_path.exists() {
-        bail!(
-            "{} already exists; refusing to modify it. \
-             Add `[env]\\n{ENV_VAR} = \"{}\"` yourself, \
-             or re-run with --no-cargo-config.",
-            config_path.display(),
-            webrtc_path.display(),
-        );
-    }
 
     if let Some(parent) = config_path.parent() {
         fs::create_dir_all(parent).with_context(|| format!("creating {}", parent.display()))?;
     }
 
-    let mut doc = DocumentMut::new();
-    let mut env_table = Table::new();
-    env_table.set_implicit(false);
-    let path_str = webrtc_path
-        .to_str()
-        .context("webrtc path is not valid UTF-8")?;
-    env_table.insert(ENV_VAR, value(path_str));
-    doc.insert("env", Item::Table(env_table));
+    let existing_content = if config_path.exists() {
+        fs::read_to_string(&config_path)
+            .with_context(|| format!("reading {}", config_path.display()))?
+    } else {
+        String::new()
+    };
+
+    let mut doc = existing_content
+        .parse::<DocumentMut>()
+        .with_context(|| format!("parsing existing {}", config_path.display()))?;
+
+    let env_table = doc
+        .entry("env")
+        .or_insert(Item::Table(Table::new()))
+        .as_table_mut()
+        .context("`env` entry is not a table")?;
+
+    let cleaned_path = clean_webrtc_path(webrtc_path)?;
+    env_table.insert(ENV_VAR, value(cleaned_path.clone()));
 
     fs::write(&config_path, doc.to_string())
         .with_context(|| format!("writing {}", config_path.display()))?;
-    eprintln!("Wrote {} with {ENV_VAR}={path_str}", config_path.display());
+
+    eprintln!(
+        "Updated {} with {ENV_VAR}={cleaned_path}",
+        config_path.display()
+    );
     Ok(())
 }
+
+fn clean_webrtc_path(path: &Path) -> Result<String> {
+    let path_str = path.to_str().context("webrtc path is not valid UTF-8")?;
+    let mut cleaned = path_str.to_string();
+    if cleaned.starts_with(r"\\?\") {
+        cleaned = cleaned[4..].to_string();
+    }
+    cleaned = cleaned.replace('\\', "/");
+    Ok(cleaned)
+}

From 980a2942929f60812ba4e6e0e2855e1ebe96c468 Mon Sep 17 00:00:00 2001
From: Higor Prado <higorevop@gmail.com>
Date: Mon, 18 May 2026 20:57:51 -0300
Subject: [PATCH 015/105] gpui: Prefer Mailbox present mode on Wayland to avoid
 FIFO stalls (#57077)

The WgpuRenderer defaults to VK_PRESENT_MODE_FIFO_KHR (vsync), which
blocks vkQueuePresentKHR until the compositor releases a buffer via
wl_surface.frame. On some Wayland compositor+driver combinations
(notably NVIDIA proprietary + Hyprland, but also observed on KDE/GNOME +
AMD RADV), these frame callbacks can be delayed or lost, stalling the
entire calloop event loop for tens of seconds.

VK_PRESENT_MODE_MAILBOX_KHR does not block on vblank: it replaces the
pending frame in a single-entry queue. This avoids the stall entirely.
The renderer already falls back to Fifo automatically if Mailbox is
unsupported by the driver.

The WgpuSurfaceConfig has had a preferred_present_mode field since
#50815 (added for Android lifecycle transitions with the same
rationale). This commit sets it to Mailbox in the Wayland window
creation path only. X11 is not affected.

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Note on tests: This change is in the Wayland platform's window creation
path (WaylandWindowState::new). The surface configuration is delegated
to WgpuRenderer which already has test coverage for
preferred_present_mode fallback logic. A full integration test would
require a running Wayland compositor in CI. Verified manually and tested
against the renderer's unwrap_or(Fifo) safety net by inspecting
surface_caps.present_modes on both NVIDIA proprietary and Mesa RADV
drivers.

Closes: #50229
Closes: #55345
Closes: #39097
Closes: #50734

Refs: #38497, #52009, #52403, #50574, #49961, #47750, #46203, #50195,
#50283, #42164, #39156, #39234, #35948, #32618

Release Notes:

- Fixed UI freezes on Linux (Wayland) when on certain GPU/driver
combinations

---------

Co-authored-by: Neel <neel@zed.dev>
---
 crates/gpui_linux/src/linux/wayland/window.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/crates/gpui_linux/src/linux/wayland/window.rs b/crates/gpui_linux/src/linux/wayland/window.rs
index 37d0f492d25..73a2bda279f 100644
--- a/crates/gpui_linux/src/linux/wayland/window.rs
+++ b/crates/gpui_linux/src/linux/wayland/window.rs
@@ -37,7 +37,7 @@ use gpui::{
     WindowDecorations, WindowKind, WindowParams, layer_shell::LayerShellNotSupportedError, px,
     size,
 };
-use gpui_wgpu::{CompositorGpuHint, WgpuRenderer, WgpuSurfaceConfig};
+use gpui_wgpu::{CompositorGpuHint, WgpuRenderer, WgpuSurfaceConfig, wgpu};
 
 #[derive(Default)]
 pub(crate) struct Callbacks {
@@ -346,7 +346,8 @@ impl WaylandWindowState {
                     height: DevicePixels(f32::from(options.bounds.size.height) as i32),
                 },
                 transparent: true,
-                preferred_present_mode: None,
+                // Prefer Mailbox to avoid blocking. Falls back to FIFO if Mailbox is unsupported.
+                preferred_present_mode: Some(wgpu::PresentMode::Mailbox),
             };
             WgpuRenderer::new(gpu_context, &raw_window, config, compositor_gpu)?
         };

From 8ca194d833a4d2e9a3f3c43f84e806a36c3839c4 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Mon, 18 May 2026 21:16:04 -0300
Subject: [PATCH 016/105] Add built-in `create-skill` skill (#57064)

Closes AI-266

This PR adds a built-in skill called `create-skill`, which allows the
Zed agent to have access to a skill that teaches it how to properly
create skills for Zed. You can manually invoke it as well as just
letting the model auto-invoke it in case your prompt suggests creating a
new skill.

Release Notes:

- Agent: Added a built-in skill called `create-skill` to make the Zed
agent informed about how to do that.

---------

Co-authored-by: Richard Feldman <richard@zed.dev>
---
 crates/acp_thread/src/mention.rs              |   1 +
 crates/agent/src/agent.rs                     | 219 +++++++++++++-----
 crates/agent/src/thread.rs                    |   6 +-
 crates/agent/src/tools/skill_tool.rs          |  51 ++--
 crates/agent_skills/agent_skills.rs           | 118 +++++++++-
 .../builtin/create-skill/SKILL.md             |  95 ++++++++
 crates/agent_ui/src/mention_set.rs            |   8 +
 crates/agent_ui/src/ui/mention_crease.rs      |  37 +++
 crates/prompt_store/src/prompts.rs            |   1 +
 9 files changed, 449 insertions(+), 87 deletions(-)
 create mode 100644 crates/agent_skills/builtin/create-skill/SKILL.md

diff --git a/crates/acp_thread/src/mention.rs b/crates/acp_thread/src/mention.rs
index 67c1ddb9416..12827acc833 100644
--- a/crates/acp_thread/src/mention.rs
+++ b/crates/acp_thread/src/mention.rs
@@ -359,6 +359,7 @@ impl MentionUri {
         match self {
             MentionUri::Skill { name, source, .. } => {
                 if source.is_empty() {
+                    // Must match `SkillSource::display_label()` in agent_skills.
                     format!("{} (global)", name)
                 } else {
                     format!("{} ({})", name, source)
diff --git a/crates/agent/src/agent.rs b/crates/agent/src/agent.rs
index eda50ab5637..ffe24590169 100644
--- a/crates/agent/src/agent.rs
+++ b/crates/agent/src/agent.rs
@@ -32,7 +32,7 @@ use acp_thread::{
 use agent_client_protocol::schema as acp;
 use agent_skills::{
     MAX_SKILL_DESCRIPTIONS_SIZE, Skill, SkillLoadError, SkillScopeId, SkillSource, SkillSummary,
-    global_skills_dir, load_skills_from_directory, project_skills_relative_path,
+    builtin_skills, global_skills_dir, load_skills_from_directory, project_skills_relative_path,
 };
 use anyhow::{Context as _, Result, anyhow};
 use chrono::{DateTime, Utc};
@@ -104,7 +104,7 @@ impl From<&Skill> for NativeAvailableSkill {
         Self {
             name: skill.name.clone(),
             description: skill.description.clone(),
-            source: skill.source.scope_prefix().to_string().into(),
+            source: skill.source.display_label().to_string().into(),
             skill_file_path: skill.skill_file_path.clone(),
         }
     }
@@ -1644,14 +1644,18 @@ impl NativeAgent {
             // Read the body on demand here — bodies live on disk between
             // materializations to keep memory cost O(total frontmatter)
             // rather than O(total file size).
-            let body = agent_skills::read_skill_body(fs.as_ref(), &skill.skill_file_path)
-                .await
-                .with_context(|| {
-                    format!(
-                        "Failed to read skill body from {}",
-                        skill.skill_file_path.display()
-                    )
-                })?;
+            let body = if let Some(embedded) = skill.embedded_body {
+                embedded.to_string()
+            } else {
+                agent_skills::read_skill_body(fs.as_ref(), &skill.skill_file_path)
+                    .await
+                    .with_context(|| {
+                        format!(
+                            "Failed to read skill body from {}",
+                            skill.skill_file_path.display()
+                        )
+                    })?
+            };
             let envelope = crate::tools::render_skill_envelope(&skill, &body);
             let envelope_block = acp::ContentBlock::Text(acp::TextContent::new(envelope));
 
@@ -2245,9 +2249,12 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
             // we don't clone the entire skill list on every prompt
             // (including prompts like `/help` that aren't skills at
             // all). The resolution rule matches the override-applied
-            // view: prefer a project-local with the matching name,
-            // falling back to a global, so the slash command picks the
-            // same entry the model sees in its catalog.
+            // view: among skills with the matching name, pick the one
+            // with the highest source precedence, so the slash command
+            // picks the same entry the model sees in its catalog.
+            // Ties (e.g. two project-local skills from different
+            // worktrees) resolve to the first in iteration order to
+            // match `apply_skill_overrides`.
             if parsed_command.explicit_server_id.is_none()
                 && parsed_command.skill_scope.is_none()
                 && !project_state.skills.is_empty()
@@ -2256,15 +2263,13 @@ impl acp_thread::AgentConnection for NativeAgentConnection {
                 let resolved = project_state
                     .skills
                     .iter()
-                    .find(|skill| {
-                        skill.name == prompt_name
-                            && matches!(skill.source, SkillSource::ProjectLocal { .. })
-                    })
-                    .or_else(|| {
-                        project_state
-                            .skills
-                            .iter()
-                            .find(|skill| skill.name == prompt_name)
+                    .filter(|skill| skill.name == prompt_name)
+                    .reduce(|best, candidate| {
+                        if candidate.source.precedence() > best.source.precedence() {
+                            candidate
+                        } else {
+                            best
+                        }
                     });
                 if let Some(skill) = resolved {
                     let skill = skill.clone();
@@ -2960,7 +2965,9 @@ fn combine_skills(
     global: Vec<Result<Skill, SkillLoadError>>,
     project: impl Iterator<Item = Result<Skill, SkillLoadError>>,
 ) -> (Vec<Skill>, Vec<SkillLoadError>) {
-    let mut skills = Vec::new();
+    // Built-in skills go first (lowest priority) so that global and
+    // project-local skills with the same name shadow them.
+    let mut skills = builtin_skills();
     let mut errors = Vec::new();
     for result in global.into_iter().chain(project) {
         match result {
@@ -2979,17 +2986,16 @@ fn log_skill_conflicts(skills: &[Skill]) {
     let mut by_name: HashMap<&str, &Skill> = HashMap::default();
     for skill in skills {
         match by_name.get(skill.name.as_str()) {
-            Some(existing) => match (&existing.source, &skill.source) {
-                (SkillSource::Global, SkillSource::ProjectLocal { .. }) => {
+            Some(existing) => {
+                if skill.source.precedence() > existing.source.precedence() {
                     log::warn!(
-                        "Project skill '{}' at '{}' overrides global skill at '{}' for the model; both appear in the slash-command popup with their source",
+                        "Skill '{}' at '{}' overrides skill at '{}' for the model; both appear in the slash-command popup with their source",
                         skill.name,
                         skill.skill_file_path.display(),
                         existing.skill_file_path.display(),
                     );
                     by_name.insert(skill.name.as_str(), skill);
-                }
-                _ => {
+                } else {
                     log::warn!(
                         "Skill '{}' at '{}' conflicts with skill at '{}'; the model will see the first one, but both appear in the slash-command popup with their source",
                         skill.name,
@@ -2997,7 +3003,7 @@ fn log_skill_conflicts(skills: &[Skill]) {
                         existing.skill_file_path.display(),
                     );
                 }
-            },
+            }
             None => {
                 by_name.insert(skill.name.as_str(), skill);
             }
@@ -3024,9 +3030,7 @@ fn apply_skill_overrides(skills: &[Skill]) -> Vec<Skill> {
     for skill in skills {
         match indices.get(skill.name.as_str()).copied() {
             Some(idx) => {
-                if matches!(result[idx].source, SkillSource::Global)
-                    && matches!(skill.source, SkillSource::ProjectLocal { .. })
-                {
+                if skill.source.precedence() > result[idx].source.precedence() {
                     result[idx] = skill.clone();
                 }
             }
@@ -3064,6 +3068,7 @@ mod internal_tests {
             directory_path: PathBuf::from(format!("/home/user/.agents/skills/{name}")),
             skill_file_path: PathBuf::from(format!("/home/user/.agents/skills/{name}/SKILL.md")),
             disable_model_invocation: false,
+            embedded_body: None,
         }
     }
 
@@ -3078,9 +3083,30 @@ mod internal_tests {
             directory_path: PathBuf::from(format!("/{worktree}/.agents/skills/{name}")),
             skill_file_path: PathBuf::from(format!("/{worktree}/.agents/skills/{name}/SKILL.md")),
             disable_model_invocation: false,
+            embedded_body: None,
         }
     }
 
+    fn make_builtin_skill(name: &str, description: &str) -> Skill {
+        Skill {
+            name: name.to_string(),
+            description: description.to_string(),
+            source: SkillSource::BuiltIn,
+            directory_path: PathBuf::from(format!("/builtin/{name}")),
+            skill_file_path: PathBuf::from(format!("/builtin/{name}/SKILL.md")),
+            disable_model_invocation: false,
+            embedded_body: Some("built-in body"),
+        }
+    }
+
+    /// Filter to only user-defined (non-built-in) skills for test assertions.
+    fn user_skills(skills: &[Skill]) -> Vec<&Skill> {
+        skills
+            .iter()
+            .filter(|s| !matches!(s.source, SkillSource::BuiltIn))
+            .collect()
+    }
+
     #[test]
     fn test_combine_skills_keeps_every_entry_for_autocomplete() {
         // The autocomplete popup needs both same-named entries so the
@@ -3092,9 +3118,10 @@ mod internal_tests {
         let (skills, errors) = combine_skills(vec![Ok(global)], vec![Ok(project)].into_iter());
 
         assert!(errors.is_empty());
-        assert_eq!(skills.len(), 2);
-        assert!(matches!(skills[0].source, SkillSource::Global));
-        assert!(matches!(skills[1].source, SkillSource::ProjectLocal { .. }));
+        let user = user_skills(&skills);
+        assert_eq!(user.len(), 2);
+        assert!(matches!(user[0].source, SkillSource::Global));
+        assert!(matches!(user[1].source, SkillSource::ProjectLocal { .. }));
     }
 
     #[test]
@@ -3130,6 +3157,51 @@ mod internal_tests {
         assert_eq!(resolved[0].description, "First");
     }
 
+    #[test]
+    fn test_apply_skill_overrides_global_wins_over_builtin() {
+        // A global skill with the same name as a built-in must shadow
+        // the built-in in the model-facing projection, regardless of
+        // iteration order.
+        let built_in = make_builtin_skill("create-skill", "Built-in version");
+        let global = make_global_skill("create-skill", "User override");
+
+        let resolved = apply_skill_overrides(&[built_in, global]);
+
+        assert_eq!(resolved.len(), 1);
+        assert_eq!(resolved[0].description, "User override");
+        assert!(matches!(resolved[0].source, SkillSource::Global));
+    }
+
+    #[test]
+    fn test_apply_skill_overrides_project_wins_over_builtin() {
+        let built_in = make_builtin_skill("create-skill", "Built-in version");
+        let project = make_project_skill("create-skill", "Project override", "my-project");
+
+        let resolved = apply_skill_overrides(&[built_in, project]);
+
+        assert_eq!(resolved.len(), 1);
+        assert_eq!(resolved[0].description, "Project override");
+        assert!(matches!(
+            resolved[0].source,
+            SkillSource::ProjectLocal { .. }
+        ));
+    }
+
+    #[test]
+    fn test_apply_skill_overrides_project_wins_over_builtin_and_global() {
+        // All three sources present — the project-local must win and
+        // both lower-precedence entries must be dropped from the
+        // model-facing projection.
+        let built_in = make_builtin_skill("create-skill", "Built-in");
+        let global = make_global_skill("create-skill", "Global");
+        let project = make_project_skill("create-skill", "Project", "my-project");
+
+        let resolved = apply_skill_overrides(&[built_in, global, project]);
+
+        assert_eq!(resolved.len(), 1);
+        assert_eq!(resolved[0].description, "Project");
+    }
+
     #[test]
     fn test_apply_skill_overrides_preserves_unique_skills() {
         let global_a = make_global_skill("alpha", "a");
@@ -3201,6 +3273,7 @@ mod internal_tests {
                 directory_path: PathBuf::from(format!("/skills/{name}")),
                 skill_file_path: PathBuf::from(format!("/skills/{name}/SKILL.md")),
                 disable_model_invocation: false,
+                embedded_body: None,
             });
         }
 
@@ -3275,6 +3348,7 @@ mod internal_tests {
             directory_path: PathBuf::from("/skills/skill-01-first"),
             skill_file_path: PathBuf::from("/skills/skill-01-first/SKILL.md"),
             disable_model_invocation: false,
+            embedded_body: None,
         };
         let second = Skill {
             name: "skill-02-overflows".to_string(),
@@ -3283,6 +3357,7 @@ mod internal_tests {
             directory_path: PathBuf::from("/skills/skill-02-overflows"),
             skill_file_path: PathBuf::from("/skills/skill-02-overflows/SKILL.md"),
             disable_model_invocation: false,
+            embedded_body: None,
         };
         let third = Skill {
             name: "skill-03-would-fit".to_string(),
@@ -3291,6 +3366,7 @@ mod internal_tests {
             directory_path: PathBuf::from("/skills/skill-03-would-fit"),
             skill_file_path: PathBuf::from("/skills/skill-03-would-fit/SKILL.md"),
             disable_model_invocation: false,
+            embedded_body: None,
         };
 
         // Sanity-check the test setup: the third skill is small enough
@@ -3346,6 +3422,7 @@ mod internal_tests {
             directory_path: PathBuf::from("/skills/hidden-huge"),
             skill_file_path: PathBuf::from("/skills/hidden-huge/SKILL.md"),
             disable_model_invocation: true,
+            embedded_body: None,
         };
         let visible = Skill {
             name: "visible".to_string(),
@@ -3354,6 +3431,7 @@ mod internal_tests {
             directory_path: PathBuf::from("/skills/visible"),
             skill_file_path: PathBuf::from("/skills/visible/SKILL.md"),
             disable_model_invocation: false,
+            embedded_body: None,
         };
 
         let (kept, errors) = select_catalog_skills(&[hidden, visible]);
@@ -3496,9 +3574,10 @@ mod internal_tests {
         // The pre-existing skill should be loaded into the project state.
         agent.read_with(cx, |agent, _cx| {
             let state = agent.projects.get(&project.entity_id()).unwrap();
-            assert_eq!(state.skills.len(), 1);
-            assert_eq!(state.skills[0].name, "my-skill");
-            assert_eq!(state.skills[0].description, "First version");
+            let user = user_skills(&state.skills);
+            assert_eq!(user.len(), 1);
+            assert_eq!(user[0].name, "my-skill");
+            assert_eq!(user[0].description, "First version");
         });
 
         // Modify the SKILL.md and verify the project context refreshes.
@@ -3512,8 +3591,9 @@ mod internal_tests {
 
         agent.read_with(cx, |agent, _cx| {
             let state = agent.projects.get(&project.entity_id()).unwrap();
-            assert_eq!(state.skills.len(), 1);
-            assert_eq!(state.skills[0].description, "Second version");
+            let user = user_skills(&state.skills);
+            assert_eq!(user.len(), 1);
+            assert_eq!(user[0].description, "Second version");
         });
     }
 
@@ -3559,8 +3639,8 @@ mod internal_tests {
         agent.read_with(cx, |agent, _cx| {
             let state = agent.projects.get(&project.entity_id()).unwrap();
             assert!(
-                state.skills.is_empty(),
-                "expected no skills before the global skills dir exists, got {:?}",
+                user_skills(&state.skills).is_empty(),
+                "expected no user skills before the global skills dir exists, got {:?}",
                 state.skills
             );
         });
@@ -3585,9 +3665,10 @@ mod internal_tests {
 
         agent.read_with(cx, |agent, _cx| {
             let state = agent.projects.get(&project.entity_id()).unwrap();
-            assert_eq!(state.skills.len(), 1);
-            assert_eq!(state.skills[0].name, "late-skill");
-            assert_eq!(state.skills[0].description, "Created after startup");
+            let user = user_skills(&state.skills);
+            assert_eq!(user.len(), 1);
+            assert_eq!(user[0].name, "late-skill");
+            assert_eq!(user[0].description, "Created after startup");
         });
     }
 
@@ -3638,8 +3719,8 @@ mod internal_tests {
         agent.read_with(cx, |agent, _cx| {
             let state = agent.projects.get(&project_id).unwrap();
             assert!(
-                state.skills.is_empty(),
-                "expected no skills before the global skills dir exists, got {:?}",
+                user_skills(&state.skills).is_empty(),
+                "expected no user skills before the global skills dir exists, got {:?}",
                 state.skills
             );
         });
@@ -3656,7 +3737,12 @@ mod internal_tests {
         // empty list — NOT the snapshot that `Thread::new` would have
         // captured.
         cx.update(|cx| {
-            assert!(resolve(cx).is_empty());
+            let all = resolve(cx);
+            let user: Vec<_> = all
+                .iter()
+                .filter(|s| !matches!(s.source, SkillSource::BuiltIn))
+                .collect();
+            assert!(user.is_empty());
         });
 
         // Now create a SKILL.md AFTER the session was registered. With
@@ -3681,15 +3767,20 @@ mod internal_tests {
         // `state.skills` reflects the new skill (the watcher ran).
         agent.read_with(cx, |agent, _cx| {
             let state = agent.projects.get(&project_id).unwrap();
-            assert_eq!(state.skills.len(), 1);
-            assert_eq!(state.skills[0].name, "my-skill");
+            let user = user_skills(&state.skills);
+            assert_eq!(user.len(), 1);
+            assert_eq!(user[0].name, "my-skill");
         });
 
         // The resolver the `SkillTool` uses must see it too. This is the
         // crux of the regression test: the tool's view of skills is
         // resolved at invocation time, not at thread-construction time.
         cx.update(|cx| {
-            let snapshot = resolve(cx);
+            let all = resolve(cx);
+            let snapshot: Vec<_> = all
+                .iter()
+                .filter(|s| !matches!(s.source, SkillSource::BuiltIn))
+                .collect();
             assert_eq!(
                 snapshot.len(),
                 1,
@@ -3777,7 +3868,11 @@ mod internal_tests {
         let parent_resolve =
             cx.update(|_cx| super::skills_resolver_for_project(agent.downgrade(), project_id));
         cx.update(|cx| {
-            let parent_skills = parent_resolve(cx);
+            let all = parent_resolve(cx);
+            let parent_skills: Vec<_> = all
+                .iter()
+                .filter(|s| !matches!(s.source, SkillSource::BuiltIn))
+                .collect();
             assert_eq!(parent_skills.len(), 1);
             assert_eq!(parent_skills[0].name, "shared-skill");
         });
@@ -3823,7 +3918,11 @@ mod internal_tests {
         let subagent_resolve = cx
             .update(|_cx| super::skills_resolver_for_project(agent.downgrade(), parent_project_id));
         cx.update(|cx| {
-            let subagent_skills = subagent_resolve(cx);
+            let all = subagent_resolve(cx);
+            let subagent_skills: Vec<_> = all
+                .iter()
+                .filter(|s| !matches!(s.source, SkillSource::BuiltIn))
+                .collect();
             assert_eq!(subagent_skills.len(), 1);
             assert_eq!(subagent_skills[0].name, "shared-skill");
         });
@@ -3919,7 +4018,14 @@ mod internal_tests {
                 .iter()
                 .map(|s| s.name.as_str())
                 .collect();
-            assert_eq!(catalog, vec!["visible-skill"]);
+            assert!(
+                catalog.contains(&"visible-skill"),
+                "visible skill missing from catalog: {catalog:?}"
+            );
+            assert!(
+                !catalog.contains(&"deploy"),
+                "deploy should be excluded from catalog: {catalog:?}"
+            );
         });
     }
 
@@ -3986,7 +4092,7 @@ mod internal_tests {
         agent.read_with(cx, |agent, cx| {
             let state = agent.projects.get(&project_id).unwrap();
             assert!(
-                state.skills.is_empty(),
+                user_skills(&state.skills).is_empty(),
                 "untrusted worktree skills should not load: {:?}",
                 state
                     .skills
@@ -4019,7 +4125,8 @@ mod internal_tests {
 
         agent.read_with(cx, |agent, _cx| {
             let state = agent.projects.get(&project_id).unwrap();
-            let names: Vec<&str> = state.skills.iter().map(|s| s.name.as_str()).collect();
+            let user = user_skills(&state.skills);
+            let names: Vec<&str> = user.iter().map(|s| s.name.as_str()).collect();
             assert_eq!(names, vec!["my-skill"]);
         });
 
diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rs
index 2fe5bc99303..ae5c5510764 100644
--- a/crates/agent/src/thread.rs
+++ b/crates/agent/src/thread.rs
@@ -364,11 +364,7 @@ impl UserMessage {
                             .ok();
                         }
                         MentionUri::Skill { name, source, .. } => {
-                            let label = if source.is_empty() {
-                                format!("{} (global)", name)
-                            } else {
-                                format!("{} ({})", name, source)
-                            };
+                            let label = format!("{} ({})", name, source);
                             write!(&mut skills_context, "\nSkill: {}\n{}\n", label, content).ok();
                         }
                     }
diff --git a/crates/agent/src/tools/skill_tool.rs b/crates/agent/src/tools/skill_tool.rs
index d45633da505..978a24f6968 100644
--- a/crates/agent/src/tools/skill_tool.rs
+++ b/crates/agent/src/tools/skill_tool.rs
@@ -46,11 +46,12 @@ fn neutralize_envelope_tags(input: &str) -> String {
 /// frontmatter), not O(total file size).
 pub fn render_skill_envelope(skill: &Skill, body: &str) -> String {
     let source = match &skill.source {
+        agent_skills::SkillSource::BuiltIn => "built-in",
         agent_skills::SkillSource::Global => "global",
         agent_skills::SkillSource::ProjectLocal { .. } => "project-local",
     };
     let worktree = match &skill.source {
-        agent_skills::SkillSource::Global => None,
+        agent_skills::SkillSource::BuiltIn | agent_skills::SkillSource::Global => None,
         agent_skills::SkillSource::ProjectLocal {
             worktree_root_name, ..
         } => Some(worktree_root_name.clone()),
@@ -200,31 +201,33 @@ impl AgentTool for SkillTool {
                 (skill.clone(), path_string)
             };
 
-            // Read the body on demand. Bodies are not kept in memory
-            // between materializations — see `agent_skills::read_skill_body`.
-            let body = agent_skills::read_skill_body(self.fs.as_ref(), &skill.skill_file_path)
-                .await
-                .map_err(|e| SkillToolOutput::Error {
-                    error: e.to_string(),
-                })?;
+            // For built-in skills the body is already in memory (compiled
+            // into the binary). For user skills, read on demand from disk.
+            let body = if let Some(embedded) = skill.embedded_body {
+                embedded.to_string()
+            } else {
+                agent_skills::read_skill_body(self.fs.as_ref(), &skill.skill_file_path)
+                    .await
+                    .map_err(|e| SkillToolOutput::Error {
+                        error: e.to_string(),
+                    })?
+            };
             let rendered = render_skill_envelope(&skill, &body);
 
-            // Activations go through the standard tool-permission flow so
-            // they participate in the same Allow-Once / Always-Allow UX as
-            // every other built-in tool. The auth context value is the
-            // skill's absolute SKILL.md path so that "always allow this
-            // specific skill" is keyed to a specific file: editing the
-            // SKILL.md will change the path's content but not the path,
-            // so for content-change re-trust we'd want a hash too — but
-            // at minimum, two skills with the same name from different
-            // locations get independent trust grants.
-            let authorize = cx.update(|cx| {
-                let context = crate::ToolPermissionContext::new(Self::NAME, vec![skill_file_path]);
-                event_stream.authorize(self.initial_title(Ok(input), cx), context, cx)
-            });
-            authorize.await.map_err(|e| SkillToolOutput::Error {
-                error: e.to_string(),
-            })?;
+            // Built-in skills ship with Zed and are trusted by default,
+            // so they skip the authorization prompt. User-installed skills
+            // go through the standard Allow-Once / Always-Allow UX.
+            let is_builtin = skill.source == agent_skills::SkillSource::BuiltIn;
+            if !is_builtin {
+                let authorize = cx.update(|cx| {
+                    let context =
+                        crate::ToolPermissionContext::new(Self::NAME, vec![skill_file_path]);
+                    event_stream.authorize(self.initial_title(Ok(input), cx), context, cx)
+                });
+                authorize.await.map_err(|e| SkillToolOutput::Error {
+                    error: e.to_string(),
+                })?;
+            }
 
             Ok(SkillToolOutput::Found { rendered })
         })
diff --git a/crates/agent_skills/agent_skills.rs b/crates/agent_skills/agent_skills.rs
index 63c506bbf64..8f185ff4ad9 100644
--- a/crates/agent_skills/agent_skills.rs
+++ b/crates/agent_skills/agent_skills.rs
@@ -64,11 +64,19 @@ pub struct Skill {
     /// `skill` tool refuses to load it. The user can still invoke it as a
     /// slash command.
     pub disable_model_invocation: bool,
+    /// For built-in skills whose content is compiled into the binary,
+    /// this holds the full SKILL.md body so the skill tool can serve it
+    /// without a filesystem read.
+    pub embedded_body: Option<&'static str>,
 }
 
 /// Indicates where a skill was loaded from.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum SkillSource {
+    /// Compiled into the Zed binary. These are always available and have
+    /// the lowest override priority (global and project-local skills can
+    /// shadow them).
+    BuiltIn,
     /// From ~/.agents/skills/
     Global,
     /// From {project}/.agents/skills/
@@ -79,6 +87,23 @@ pub enum SkillSource {
 }
 
 impl SkillSource {
+    /// Precedence for resolving same-named skills. Higher values shadow
+    /// lower ones: `ProjectLocal` > `Global` > `BuiltIn`. Two sources
+    /// returning equal precedence (e.g. two project-local skills from
+    /// different worktrees) leave the winner up to the caller, which by
+    /// convention keeps the first one in iteration order.
+    ///
+    /// Adding a new `SkillSource` variant should be a one-line change
+    /// here — every consumer routes through this method so the hierarchy
+    /// stays in sync.
+    pub fn precedence(&self) -> u8 {
+        match self {
+            Self::BuiltIn => 0,
+            Self::Global => 1,
+            Self::ProjectLocal { .. } => 2,
+        }
+    }
+
     /// Scope prefix used in the `/<prefix>:<name>` slash-command
     /// syntax that the autocomplete popup inserts. Global skills use
     /// an empty prefix (so the inserted text is `/:<name>`), and
@@ -91,9 +116,21 @@ impl SkillSource {
     /// invoked as `/:<name>`, and the worktree's skill is invoked as
     /// `/global:<name>`. The two grammars never collide on the
     /// inserted text.
+    /// Human-readable label for this source, used in the UI to
+    /// distinguish skills from different origins.
+    pub fn display_label(&self) -> &str {
+        match self {
+            Self::BuiltIn => "built-in",
+            Self::Global => "global",
+            Self::ProjectLocal {
+                worktree_root_name, ..
+            } => worktree_root_name.as_ref(),
+        }
+    }
+
     pub fn scope_prefix(&self) -> &str {
         match self {
-            Self::Global => "",
+            Self::BuiltIn | Self::Global => "",
             Self::ProjectLocal {
                 worktree_root_name, ..
             } => worktree_root_name.as_ref(),
@@ -112,7 +149,7 @@ impl SkillSource {
     /// strictness only affects users typing by memory.
     pub fn matches_scope(&self, scope: &str) -> bool {
         match self {
-            Self::Global => scope.is_empty(),
+            Self::BuiltIn | Self::Global => scope.is_empty(),
             Self::ProjectLocal {
                 worktree_root_name, ..
             } => !scope.is_empty() && worktree_root_name.as_ref() == scope,
@@ -211,6 +248,7 @@ pub fn parse_skill_frontmatter(
         directory_path,
         skill_file_path: skill_file_path.to_path_buf(),
         disable_model_invocation: metadata.disable_model_invocation,
+        embedded_body: None,
     })
 }
 
@@ -600,6 +638,53 @@ pub async fn read_skill_body(
     Ok(body.trim().to_string())
 }
 
+/// Content of the built-in `create-skill` SKILL.md, embedded at compile time.
+const CREATE_SKILL_CONTENT: &str = include_str!("builtin/create-skill/SKILL.md");
+
+/// Returns the set of skills that are compiled into the Zed binary.
+pub fn builtin_skills() -> Vec<Skill> {
+    let mut skills = Vec::new();
+    if let Ok(skill) = parse_builtin_skill("create-skill", CREATE_SKILL_CONTENT) {
+        skills.push(skill);
+    }
+    skills
+}
+
+/// Parse a built-in skill from its embedded SKILL.md content. The skill
+/// gets a synthetic `<built-in>` path since it doesn't live on disk.
+fn parse_builtin_skill(name: &str, content: &'static str) -> Result<Skill> {
+    let (metadata, body) = extract_frontmatter(content)?;
+    validate_name(&metadata.name)?;
+    validate_description(&metadata.description)?;
+
+    let synthetic_dir = PathBuf::from(format!("<built-in>/{}", name));
+    let synthetic_path = synthetic_dir.join(SKILL_FILE_NAME);
+
+    Ok(Skill {
+        name: metadata.name,
+        description: metadata.description,
+        source: SkillSource::BuiltIn,
+        directory_path: synthetic_dir,
+        skill_file_path: synthetic_path,
+        disable_model_invocation: metadata.disable_model_invocation,
+        embedded_body: Some(body.trim()),
+    })
+}
+
+/// All built-in skills as `(name, raw_content)` pairs. Used by
+/// `builtin_skill_content` to serve the full SKILL.md without disk I/O.
+const BUILTIN_SKILL_ENTRIES: &[(&str, &str)] = &[("create-skill", CREATE_SKILL_CONTENT)];
+
+/// Look up the full embedded content of a built-in skill by its
+/// synthetic file path. Returns `None` if the path doesn't match any
+/// built-in skill.
+pub fn builtin_skill_content(skill_file_path: &Path) -> Option<&'static str> {
+    BUILTIN_SKILL_ENTRIES.iter().find_map(|(name, content)| {
+        let expected = PathBuf::from(format!("<built-in>/{}", name)).join(SKILL_FILE_NAME);
+        (expected == skill_file_path).then_some(*content)
+    })
+}
+
 /// Returns the global skills directory: `~/.agents/skills`.
 ///
 /// Other agents (e.g. Claude Code) already write skill files into this
@@ -663,6 +748,34 @@ mod tests {
     use fs::FakeFs;
     use gpui::TestAppContext;
 
+    #[test]
+    fn test_skill_source_precedence_is_total_and_ordered() {
+        // Pin the hierarchy: project-local > global > built-in. Every
+        // override and conflict-resolution site routes through this,
+        // so the rest of the codebase relies on it being correct.
+        let built_in = SkillSource::BuiltIn.precedence();
+        let global = SkillSource::Global.precedence();
+        let project = SkillSource::ProjectLocal {
+            worktree_id: SkillScopeId(1),
+            worktree_root_name: "my-project".into(),
+        }
+        .precedence();
+
+        assert!(built_in < global, "global must shadow built-in");
+        assert!(global < project, "project-local must shadow global");
+
+        // Two project-local skills from different worktrees tie. The
+        // "first wins" convention is enforced by the callers, but the
+        // precedence itself must be equal so neither silently shadows
+        // the other.
+        let other_project = SkillSource::ProjectLocal {
+            worktree_id: SkillScopeId(2),
+            worktree_root_name: "other-project".into(),
+        }
+        .precedence();
+        assert_eq!(project, other_project);
+    }
+
     #[test]
     fn test_parse_valid_skill() {
         let content = r#"---
@@ -1532,6 +1645,7 @@ description: A skill with no body content
             directory_path: PathBuf::from("/skills/test-skill"),
             skill_file_path: PathBuf::from("/skills/test-skill/SKILL.md"),
             disable_model_invocation: false,
+            embedded_body: None,
         };
 
         let summary = SkillSummary::from(&skill);
diff --git a/crates/agent_skills/builtin/create-skill/SKILL.md b/crates/agent_skills/builtin/create-skill/SKILL.md
new file mode 100644
index 00000000000..c5c76d80b8f
--- /dev/null
+++ b/crates/agent_skills/builtin/create-skill/SKILL.md
@@ -0,0 +1,95 @@
+---
+name: create-skill
+description: Helps users create new agent skills for Zed. Use this when a user wants to create a skill, asks about SKILL.md structure, or wants to package reusable agent instructions.
+---
+
+# Creating a Zed Agent Skill
+
+Use this skill when the user wants to create, edit, or understand agent skills in Zed.
+
+## What is a Skill?
+
+A skill is a reusable set of instructions that an agent can load on demand. Each skill lives in its own directory and is defined by a `SKILL.md` file with YAML frontmatter.
+
+## Where Skills Live
+
+Skills can be placed in two locations:
+
+| Scope | Path | When to use |
+|-------|------|-------------|
+| Global | `~/.agents/skills/<skill-name>/SKILL.md` | Personal skills, available in all projects |
+| Project-local | `<project>/.agents/skills/<skill-name>/SKILL.md` | Project-specific skills, shared with collaborators through version control |
+
+Prefer project-local when the skill is specific to a repository. Prefer global when the skill is a personal workflow the user wants everywhere.
+
+## SKILL.md Format
+
+Every `SKILL.md` must start with YAML frontmatter between `---` delimiters:
+
+```markdown
+---
+name: my-skill-name
+description: A clear, specific description of what this skill does and when to use it.
+---
+
+# Skill Title
+
+Instructions for the agent go here. Write them as if you're telling the agent
+what to do when this skill is activated.
+```
+
+### Required Frontmatter Fields
+
+- **`name`** (required): Must be 1–64 characters, lowercase alphanumeric with single-hyphen separators. Must match the containing directory name exactly. Regex: `^[a-z0-9]+(-[a-z0-9]+)*$`
+- **`description`** (required): Must be 1–1024 characters. This is what the agent sees when deciding whether to use the skill — make it specific and actionable.
+
+### Optional Frontmatter Fields
+
+- **`disable-model-invocation`**: When set to `true`, the skill is hidden from the agent's automatic catalog. The user can still invoke it manually via the `/` slash command menu. Useful for skills that should only run when explicitly requested.
+
+## Naming Rules
+
+The skill name must:
+- Be lowercase letters and numbers only, with single hyphens as separators
+- Not start or end with `-`
+- Not contain consecutive `--`
+- Match the directory name that contains the `SKILL.md`
+
+Good: `git-release`, `pr-review`, `rust-patterns`
+Bad: `Git-Release`, `pr--review`, `-my-skill`, `my_skill`
+
+## Writing Good Skill Instructions
+
+The body of the SKILL.md (after the frontmatter) contains the instructions the agent will follow. Guidelines:
+
+1. **Be direct**: Write instructions as if talking to the agent. "Do X", "Check Y", "Ask the user about Z".
+2. **Be specific**: Include concrete file paths, commands, formats, and patterns.
+3. **Include when-to-use guidance**: Help the agent understand the right context for this skill.
+4. **Reference supporting files**: Skills can include additional files in their directory. Reference them with relative paths (e.g., `templates/component.tsx`). The agent can read these files when the skill is activated.
+5. **Keep descriptions actionable**: The `description` field is the agent's primary signal for whether to load this skill. "Helps with code" is too vague. "Generate React components following the project's design system patterns" is specific.
+
+## Supporting Files
+
+A skill directory can contain additional files beyond `SKILL.md`:
+
+```
+~/.agents/skills/react-component/
+├── SKILL.md
+├── templates/
+│   ├── component.tsx
+│   └── test.tsx
+└── examples/
+    └── button.tsx
+```
+
+Reference these in the skill body. The agent can read them using the file path shown in the `<directory>` tag of the skill envelope.
+
+## Step-by-Step: Creating a Skill
+
+1. Decide on scope (global vs project-local) based on the user's needs.
+2. Choose a descriptive, hyphenated name.
+3. Create the directory structure.
+4. Write the `SKILL.md` with frontmatter and instructions.
+5. Optionally add supporting files (templates, examples, references).
+
+After creating the skill, it will be automatically discovered by Zed's agent on the next conversation (no restart needed for global skills if the `~/.agents/skills/` directory already exists).
diff --git a/crates/agent_ui/src/mention_set.rs b/crates/agent_ui/src/mention_set.rs
index 31bb31c046c..d1335d31811 100644
--- a/crates/agent_ui/src/mention_set.rs
+++ b/crates/agent_ui/src/mention_set.rs
@@ -491,6 +491,14 @@ impl MentionSet {
         skill_file_path: PathBuf,
         cx: &mut Context<Self>,
     ) -> Task<Result<Mention>> {
+        // Built-in skills have synthetic paths that don't exist on disk;
+        // serve their content directly from the compiled-in data.
+        if let Some(content) = agent_skills::builtin_skill_content(&skill_file_path) {
+            return Task::ready(Ok(Mention::Text {
+                content: content.to_string(),
+                tracked_buffers: Vec::new(),
+            }));
+        }
         cx.background_spawn(async move {
             let content = std::fs::read_to_string(&skill_file_path).map_err(|e| {
                 anyhow!(
diff --git a/crates/agent_ui/src/ui/mention_crease.rs b/crates/agent_ui/src/ui/mention_crease.rs
index 4d4b282cf0b..f71ecedae21 100644
--- a/crates/agent_ui/src/ui/mention_crease.rs
+++ b/crates/agent_ui/src/ui/mention_crease.rs
@@ -203,6 +203,43 @@ fn open_skill_file(
     window: &mut Window,
     cx: &mut Context<Workspace>,
 ) {
+    // Built-in skills have synthetic paths that don't exist on disk.
+    // Open a read-only buffer with the embedded content instead.
+    if let Some(content) = agent_skills::builtin_skill_content(&skill_file_path) {
+        let project = workspace.project().clone();
+        let languages = project.read(cx).languages().clone();
+        let buffer = project.update(cx, |project, cx| {
+            project.create_local_buffer(content, None, false, cx)
+        });
+        // Set markdown highlighting asynchronously — the buffer
+        // opens instantly and the highlighting appears once loaded.
+        cx.spawn({
+            let buffer = buffer.clone();
+            async move |_, cx| {
+                if let Ok(markdown) = languages.language_for_name("Markdown").await {
+                    buffer.update(cx, |buffer, cx| buffer.set_language(Some(markdown), cx));
+                }
+            }
+        })
+        .detach();
+        let editor = cx.new(|cx| {
+            let mut editor = Editor::for_buffer(buffer, None, window, cx);
+            editor.set_read_only(true);
+            let title = skill_file_path
+                .parent()
+                .and_then(|p| p.file_name())
+                .map(|n| n.to_string_lossy().into_owned())
+                .unwrap_or_else(|| "built-in skill".into());
+            editor
+                .buffer()
+                .update(cx, |buffer, cx| buffer.set_title(title, cx));
+            editor
+        });
+        let pane = workspace.active_pane().clone();
+        workspace.add_item(pane, Box::new(editor), None, true, true, window, cx);
+        return;
+    }
+
     workspace
         .open_abs_path(
             skill_file_path,
diff --git a/crates/prompt_store/src/prompts.rs b/crates/prompt_store/src/prompts.rs
index b3194dd1d61..6417f49f85b 100644
--- a/crates/prompt_store/src/prompts.rs
+++ b/crates/prompt_store/src/prompts.rs
@@ -163,6 +163,7 @@ mod tests {
             directory_path: PathBuf::from("/skills/oversized"),
             skill_file_path: PathBuf::from("/skills/oversized/SKILL.md"),
             disable_model_invocation: false,
+            embedded_body: None,
         };
         let summary = SkillSummary::from(&skill);
 

From 14befe215158182be6b505b26bccf25538831213 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <git@maxdeviant.com>
Date: Tue, 19 May 2026 02:44:48 -0400
Subject: [PATCH 017/105] agent: Fix a panic when splitting streamed-in edits
 inside of a multibyte character (#57100)

This PR fixes a panic that could occur in the `edit_file` tool where
streaming in text could split in the middle of a multibyte character.

Closes FR-3 and [ZED-7ZX](https://zed-dev.sentry.io/issues/7480598098).

Release Notes:

- Fixed a panic that could occur when streaming in text with the
`edit_file` tool.
---
 .../tools/edit_session/streaming_parser.rs    | 113 ++++++++++++++++--
 1 file changed, 106 insertions(+), 7 deletions(-)

diff --git a/crates/agent/src/tools/edit_session/streaming_parser.rs b/crates/agent/src/tools/edit_session/streaming_parser.rs
index 3961edf564c..71dbc2c9bba 100644
--- a/crates/agent/src/tools/edit_session/streaming_parser.rs
+++ b/crates/agent/src/tools/edit_session/streaming_parser.rs
@@ -113,7 +113,7 @@ impl StreamingParser {
             {
                 if partial.new_text.is_some() && !state.buffer_new_text_until_old_text_done {
                     // new_text appeared after old_text, so old_text is done — emit everything.
-                    let start = state.old_text_emitted_len.min(old_text.len());
+                    let start = find_char_boundary(old_text, state.old_text_emitted_len);
                     let chunk = normalize_done_chunk(old_text[start..].to_string());
                     state.old_text_done = true;
                     state.old_text_emitted_len = old_text.len();
@@ -124,9 +124,10 @@ impl StreamingParser {
                     });
                 } else {
                     let safe_end = safe_emit_end_for_edit_text(old_text);
+                    let safe_start = find_char_boundary(old_text, state.old_text_emitted_len);
 
-                    if safe_end > state.old_text_emitted_len {
-                        let chunk = old_text[state.old_text_emitted_len..safe_end].to_string();
+                    if safe_end > safe_start {
+                        let chunk = old_text[safe_start..safe_end].to_string();
                         state.old_text_emitted_len = safe_end;
                         events.push(EditEvent::OldTextChunk {
                             edit_index: index,
@@ -143,9 +144,10 @@ impl StreamingParser {
                 && !state.new_text_done
             {
                 let safe_end = safe_emit_end_for_edit_text(new_text);
+                let safe_start = find_char_boundary(new_text, state.new_text_emitted_len);
 
-                if safe_end > state.new_text_emitted_len {
-                    let chunk = new_text[state.new_text_emitted_len..safe_end].to_string();
+                if safe_end > safe_start {
+                    let chunk = new_text[safe_start..safe_end].to_string();
                     state.new_text_emitted_len = safe_end;
                     events.push(EditEvent::NewTextChunk {
                         edit_index: index,
@@ -343,8 +345,10 @@ impl StreamingParser {
 /// held back because it may be an artifact of the partial JSON fixer closing
 /// an incomplete escape sequence (e.g. turning a half-received `\n` into `\\`).
 /// The next partial will reveal the correct character.
+///
+/// The returned position is always a valid UTF-8 character boundary.
 fn safe_emit_end(text: &str) -> usize {
-    if text.as_bytes().last() == Some(&b'\\') {
+    if text.ends_with('\\') {
         text.len() - 1
     } else {
         text.len()
@@ -353,13 +357,35 @@ fn safe_emit_end(text: &str) -> usize {
 
 fn safe_emit_end_for_edit_text(text: &str) -> usize {
     let safe_end = safe_emit_end(text);
-    if safe_end > 0 && text.as_bytes()[safe_end - 1] == b'\n' {
+    // Use string slicing to check the last character, ensuring we respect UTF-8 boundaries.
+    if safe_end > 0 && text[..safe_end].ends_with('\n') {
         safe_end - 1
     } else {
         safe_end
     }
 }
 
+/// Finds a valid UTF-8 character boundary at or before the target position.
+///
+/// When streaming partial JSON, the text structure can change between updates
+/// (e.g., an escape sequence being completed). This means a byte position that
+/// was valid in one partial may land inside a multi-byte character in the next.
+/// This function finds the nearest valid boundary at or before the target.
+fn find_char_boundary(text: &str, target: usize) -> usize {
+    if target >= text.len() {
+        return text.len();
+    }
+    if text.is_char_boundary(target) {
+        return target;
+    }
+    // Walk backwards to find a valid boundary.
+    let mut pos = target;
+    while pos > 0 && !text.is_char_boundary(pos) {
+        pos -= 1;
+    }
+    pos
+}
+
 fn normalize_done_chunk(mut chunk: String) -> String {
     if chunk.ends_with('\n') {
         chunk.pop();
@@ -1146,4 +1172,77 @@ mod tests {
             }]
         );
     }
+
+    #[test]
+    fn test_multibyte_char_with_trailing_backslash() {
+        // Reproduces a panic where the stored `old_text_emitted_len` from a previous
+        // partial lands inside a multi-byte UTF-8 character in the current partial.
+        //
+        // Scenario: The JSON fixer produces a literal backslash when the stream cuts
+        // mid-escape. If the *next* partial replaces that backslash with a multi-byte
+        // character (e.g., em-dash '—'), the stored byte position is no longer valid.
+        let mut parser = StreamingParser::default();
+
+        // First partial: text ends with backslash (held back by safe_emit_end).
+        // "abc" = 3 bytes, backslash held back, so emitted_len = 3.
+        let events = parser.push_edits(&[PartialEdit {
+            old_text: Some("abc\\".into()),
+            new_text: None,
+        }]);
+        assert_eq!(
+            events.as_slice(),
+            &[EditEvent::OldTextChunk {
+                edit_index: 0,
+                chunk: "abc".into(),
+                done: false,
+            }]
+        );
+
+        // Second partial: the backslash is replaced by em-dash '—' (3 bytes: E2 80 94).
+        // "ab—" = 2 + 3 = 5 bytes total, with em-dash at bytes 2..5.
+        // The stored emitted_len (3) is inside the em-dash!
+        // This should NOT panic.
+        let events = parser.push_edits(&[PartialEdit {
+            old_text: Some("ab—".into()),
+            new_text: None,
+        }]);
+        // The parser should handle this gracefully.
+        let _ = events;
+    }
+
+    #[test]
+    fn test_emitted_len_inside_multibyte_char_boundary() {
+        // More direct reproduction: emitted_len points inside a multi-byte character.
+        //
+        // This can happen when:
+        // 1. First partial has text where byte N is a valid boundary
+        // 2. Second partial has *different* text where byte N is inside a multi-byte char
+        let mut parser = StreamingParser::default();
+
+        // First partial: "ab" (2 bytes), backslash held back.
+        // After processing: emitted_len = 2
+        let events = parser.push_edits(&[PartialEdit {
+            old_text: Some("ab\\".into()),
+            new_text: None,
+        }]);
+        assert_eq!(
+            events.as_slice(),
+            &[EditEvent::OldTextChunk {
+                edit_index: 0,
+                chunk: "ab".into(),
+                done: false,
+            }]
+        );
+
+        // Second partial: "a—" where em-dash starts at byte 1 and spans bytes 1-3.
+        // Stored emitted_len = 2, but byte 2 is inside the em-dash!
+        // This should NOT panic.
+        let events = parser.push_edits(&[PartialEdit {
+            old_text: Some("a—".into()),
+            new_text: None,
+        }]);
+        // The parser should handle this gracefully.
+        // We don't care exactly what it emits, just that it doesn't panic.
+        let _ = events;
+    }
 }

From b8dce970fa49fca372d1a86188715a5665dbe561 Mon Sep 17 00:00:00 2001
From: "zed-zippy[bot]" <234243425+zed-zippy[bot]@users.noreply.github.com>
Date: Tue, 19 May 2026 09:01:38 +0200
Subject: [PATCH 018/105] extension_ci: Bump extension CLI version to `2a00db0`
 (#57098)

This PR bumps the extension CLI version used in the extension workflows
to `2a00db06ce6d01089bfafd207b6348078e980df9`.

Release Notes:

- N/A

Co-authored-by: zed-zippy[bot] <234243425+zed-zippy[bot]@users.noreply.github.com>
---
 .github/workflows/extension_bump.yml                 | 2 +-
 .github/workflows/extension_tests.yml                | 2 +-
 tooling/xtask/src/tasks/workflows/extension_tests.rs | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/extension_bump.yml b/.github/workflows/extension_bump.yml
index 4757db43437..11a3a709022 100644
--- a/.github/workflows/extension_bump.yml
+++ b/.github/workflows/extension_bump.yml
@@ -5,7 +5,7 @@ env:
   CARGO_TERM_COLOR: always
   RUST_BACKTRACE: '1'
   CARGO_INCREMENTAL: '0'
-  ZED_EXTENSION_CLI_SHA: 1fa7f1a3ec28ea1eae6db2e937d7a538fb10c0c7
+  ZED_EXTENSION_CLI_SHA: 2a00db06ce6d01089bfafd207b6348078e980df9
 on:
   workflow_call:
     inputs:
diff --git a/.github/workflows/extension_tests.yml b/.github/workflows/extension_tests.yml
index 4003f41c273..c3503590e60 100644
--- a/.github/workflows/extension_tests.yml
+++ b/.github/workflows/extension_tests.yml
@@ -5,7 +5,7 @@ env:
   CARGO_TERM_COLOR: always
   RUST_BACKTRACE: '1'
   CARGO_INCREMENTAL: '0'
-  ZED_EXTENSION_CLI_SHA: 1fa7f1a3ec28ea1eae6db2e937d7a538fb10c0c7
+  ZED_EXTENSION_CLI_SHA: 2a00db06ce6d01089bfafd207b6348078e980df9
   RUSTUP_TOOLCHAIN: stable
   CARGO_BUILD_TARGET: wasm32-wasip2
 on:
diff --git a/tooling/xtask/src/tasks/workflows/extension_tests.rs b/tooling/xtask/src/tasks/workflows/extension_tests.rs
index 56aeb677eac..f93415f2077 100644
--- a/tooling/xtask/src/tasks/workflows/extension_tests.rs
+++ b/tooling/xtask/src/tasks/workflows/extension_tests.rs
@@ -14,7 +14,7 @@ use crate::tasks::workflows::{
     vars::{PathCondition, StepOutput, WorkflowInput, one_workflow_per_non_main_branch_and_token},
 };
 
-pub(crate) const ZED_EXTENSION_CLI_SHA: &str = "1fa7f1a3ec28ea1eae6db2e937d7a538fb10c0c7";
+pub(crate) const ZED_EXTENSION_CLI_SHA: &str = "2a00db06ce6d01089bfafd207b6348078e980df9";
 
 // This should follow the set target in crates/extension/src/extension_builder.rs
 const EXTENSION_RUST_TARGET: &str = "wasm32-wasip2";

From 8708a6fa749e0be85d378377369c539e9da244a7 Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Tue, 19 May 2026 11:51:42 +0200
Subject: [PATCH 019/105] agent: Do not decode images during render (#56866)

Turns out we were creating an ImageDecoder on every frame (added in
#46167) when a tool returned an image as output, because we were trying
to get its dimensions. That is now cached on `ContentBlock::Image`.

Release Notes:

- N/A
---
 crates/acp_thread/Cargo.toml                  |  4 +-
 crates/acp_thread/src/acp_thread.rs           | 49 ++++++++---
 .../src/conversation_view/thread_view.rs      | 85 +++++++++----------
 3 files changed, 79 insertions(+), 59 deletions(-)

diff --git a/crates/acp_thread/Cargo.toml b/crates/acp_thread/Cargo.toml
index 987db1dcf8e..9123c301079 100644
--- a/crates/acp_thread/Cargo.toml
+++ b/crates/acp_thread/Cargo.toml
@@ -13,7 +13,7 @@ path = "src/acp_thread.rs"
 doctest = false
 
 [features]
-test-support = ["gpui/test-support", "project/test-support", "dep:parking_lot", "dep:image"]
+test-support = ["gpui/test-support", "project/test-support", "dep:parking_lot"]
 
 [dependencies]
 action_log.workspace = true
@@ -35,7 +35,7 @@ language_model.workspace = true
 log.workspace = true
 markdown.workspace = true
 parking_lot = { workspace = true, optional = true }
-image = { workspace = true, optional = true }
+image.workspace = true
 portable-pty.workspace = true
 project.workspace = true
 prompt_store.workspace = true
diff --git a/crates/acp_thread/src/acp_thread.rs b/crates/acp_thread/src/acp_thread.rs
index afd8aeda5f3..4e6be0fe6a1 100644
--- a/crates/acp_thread/src/acp_thread.rs
+++ b/crates/acp_thread/src/acp_thread.rs
@@ -648,9 +648,16 @@ impl Display for ToolCallStatus {
 #[derive(Debug, PartialEq, Clone)]
 pub enum ContentBlock {
     Empty,
-    Markdown { markdown: Entity<Markdown> },
-    ResourceLink { resource_link: acp::ResourceLink },
-    Image { image: Arc<gpui::Image> },
+    Markdown {
+        markdown: Entity<Markdown>,
+    },
+    ResourceLink {
+        resource_link: acp::ResourceLink,
+    },
+    Image {
+        image: Arc<gpui::Image>,
+        dimensions: Option<gpui::Size<u32>>,
+    },
 }
 
 impl ContentBlock {
@@ -692,8 +699,8 @@ impl ContentBlock {
                 };
             }
             (ContentBlock::Empty, acp::ContentBlock::Image(image_content)) => {
-                if let Some(image) = Self::decode_image(image_content) {
-                    *self = ContentBlock::Image { image };
+                if let Some((image, dimensions)) = Self::decode_image(image_content) {
+                    *self = ContentBlock::Image { image, dimensions };
                 } else {
                     let new_content = Self::image_md(image_content);
                     *self = Self::create_markdown_block(new_content, language_registry, cx);
@@ -721,14 +728,36 @@ impl ContentBlock {
         }
     }
 
-    fn decode_image(image_content: &acp::ImageContent) -> Option<Arc<gpui::Image>> {
+    fn decode_image(
+        image_content: &acp::ImageContent,
+    ) -> Option<(Arc<gpui::Image>, Option<gpui::Size<u32>>)> {
         use base64::Engine as _;
 
         let bytes = base64::engine::general_purpose::STANDARD
             .decode(image_content.data.as_bytes())
             .ok()?;
         let format = gpui::ImageFormat::from_mime_type(&image_content.mime_type)?;
-        Some(Arc::new(gpui::Image::from_bytes(format, bytes)))
+        let dimensions = Self::image_dimensions(&bytes, format);
+        Some((Arc::new(gpui::Image::from_bytes(format, bytes)), dimensions))
+    }
+
+    fn image_dimensions(bytes: &[u8], format: gpui::ImageFormat) -> Option<gpui::Size<u32>> {
+        let format = match format {
+            gpui::ImageFormat::Png => image::ImageFormat::Png,
+            gpui::ImageFormat::Jpeg => image::ImageFormat::Jpeg,
+            gpui::ImageFormat::Webp => image::ImageFormat::WebP,
+            gpui::ImageFormat::Gif => image::ImageFormat::Gif,
+            gpui::ImageFormat::Svg => return None,
+            gpui::ImageFormat::Bmp => image::ImageFormat::Bmp,
+            gpui::ImageFormat::Tiff => image::ImageFormat::Tiff,
+            gpui::ImageFormat::Ico => image::ImageFormat::Ico,
+            gpui::ImageFormat::Pnm => image::ImageFormat::Pnm,
+        };
+
+        image::ImageReader::with_format(std::io::Cursor::new(bytes), format)
+            .into_dimensions()
+            .ok()
+            .map(|(width, height)| gpui::Size { width, height })
     }
 
     fn create_markdown_block(
@@ -808,9 +837,9 @@ impl ContentBlock {
         }
     }
 
-    pub fn image(&self) -> Option<&Arc<gpui::Image>> {
+    pub fn image(&self) -> Option<(&Arc<gpui::Image>, Option<gpui::Size<u32>>)> {
         match self {
-            ContentBlock::Image { image } => Some(image),
+            ContentBlock::Image { image, dimensions } => Some((image, *dimensions)),
             _ => None,
         }
     }
@@ -895,7 +924,7 @@ impl ToolCallContent {
         }
     }
 
-    pub fn image(&self) -> Option<&Arc<gpui::Image>> {
+    pub fn image(&self) -> Option<(&Arc<gpui::Image>, Option<gpui::Size<u32>>)> {
         match self {
             Self::ContentBlock(content) => content.image(),
             _ => None,
diff --git a/crates/agent_ui/src/conversation_view/thread_view.rs b/crates/agent_ui/src/conversation_view/thread_view.rs
index 9d78baf826c..6b63abd50ea 100644
--- a/crates/agent_ui/src/conversation_view/thread_view.rs
+++ b/crates/agent_ui/src/conversation_view/thread_view.rs
@@ -6446,7 +6446,6 @@ impl ThreadView {
                                         content_ix,
                                         tool_call,
                                         use_card_layout,
-                                        has_image_content,
                                         failed_or_canceled,
                                         focus_handle,
                                         window,
@@ -6578,7 +6577,6 @@ impl ThreadView {
                                         content_ix,
                                         tool_call,
                                         use_card_layout,
-                                        has_image_content,
                                         failed_or_canceled,
                                         focus_handle,
                                         window,
@@ -7570,7 +7568,6 @@ impl ThreadView {
         context_ix: usize,
         tool_call: &ToolCall,
         card_layout: bool,
-        is_image_tool_call: bool,
         has_failed: bool,
         focus_handle: &FocusHandle,
         window: &Window,
@@ -7589,14 +7586,14 @@ impl ThreadView {
                         window,
                         cx,
                     )
-                } else if let Some(image) = content.image() {
+                } else if let Some((image, dimensions)) = content.image() {
                     let location = tool_call.locations.first().cloned();
                     self.render_image_output(
                         entry_ix,
                         image.clone(),
+                        dimensions,
                         location,
                         card_layout,
-                        is_image_tool_call,
                         cx,
                     )
                 } else {
@@ -7778,30 +7775,26 @@ impl ThreadView {
         &self,
         entry_ix: usize,
         image: Arc<gpui::Image>,
+        dimensions: Option<gpui::Size<u32>>,
         location: Option<acp::ToolCallLocation>,
         card_layout: bool,
-        show_dimensions: bool,
         cx: &Context<Self>,
     ) -> AnyElement {
-        let dimensions_label = if show_dimensions {
-            let format_name = match image.format() {
-                gpui::ImageFormat::Png => "PNG",
-                gpui::ImageFormat::Jpeg => "JPEG",
-                gpui::ImageFormat::Webp => "WebP",
-                gpui::ImageFormat::Gif => "GIF",
-                gpui::ImageFormat::Svg => "SVG",
-                gpui::ImageFormat::Bmp => "BMP",
-                gpui::ImageFormat::Tiff => "TIFF",
-                gpui::ImageFormat::Ico => "ICO",
-                gpui::ImageFormat::Pnm => "PNM",
-            };
-            let dimensions = image::ImageReader::new(std::io::Cursor::new(image.bytes()))
-                .with_guessed_format()
-                .ok()
-                .and_then(|reader| reader.into_dimensions().ok());
-            dimensions.map(|(w, h)| format!("{}×{} {}", w, h, format_name))
+        let format_name = match image.format() {
+            gpui::ImageFormat::Png => "PNG",
+            gpui::ImageFormat::Jpeg => "JPEG",
+            gpui::ImageFormat::Webp => "WebP",
+            gpui::ImageFormat::Gif => "GIF",
+            gpui::ImageFormat::Svg => "SVG",
+            gpui::ImageFormat::Bmp => "BMP",
+            gpui::ImageFormat::Tiff => "TIFF",
+            gpui::ImageFormat::Ico => "ICO",
+            gpui::ImageFormat::Pnm => "PNM",
+        };
+        let dimensions_label = if let Some(size) = dimensions {
+            format!("{}×{} {}", size.width, size.height, format_name)
         } else {
-            None
+            format_name.into()
         };
 
         v_flex()
@@ -7816,29 +7809,27 @@ impl ThreadView {
                         .border_color(self.tool_card_border_color(cx))
                 }
             })
-            .when(dimensions_label.is_some() || location.is_some(), |this| {
-                this.child(
-                    h_flex()
-                        .w_full()
-                        .justify_between()
-                        .items_center()
-                        .children(dimensions_label.map(|label| {
-                            Label::new(label)
-                                .size(LabelSize::XSmall)
-                                .color(Color::Muted)
-                                .buffer_font(cx)
-                        }))
-                        .when_some(location, |this, _loc| {
-                            this.child(
-                                Button::new(("go-to-file", entry_ix), "Go to File")
-                                    .label_size(LabelSize::Small)
-                                    .on_click(cx.listener(move |this, _, window, cx| {
-                                        this.open_tool_call_location(entry_ix, 0, window, cx);
-                                    })),
-                            )
-                        }),
-                )
-            })
+            .child(
+                h_flex()
+                    .w_full()
+                    .justify_between()
+                    .items_center()
+                    .child(
+                        Label::new(dimensions_label)
+                            .size(LabelSize::XSmall)
+                            .color(Color::Muted)
+                            .buffer_font(cx),
+                    )
+                    .when_some(location, |this, _loc| {
+                        this.child(
+                            Button::new(("go-to-file", entry_ix), "Go to File")
+                                .label_size(LabelSize::Small)
+                                .on_click(cx.listener(move |this, _, window, cx| {
+                                    this.open_tool_call_location(entry_ix, 0, window, cx);
+                                })),
+                        )
+                    }),
+            )
             .child(
                 img(image)
                     .max_w_96()

From 938490639a9980f84902a916801a3cb79304b7c8 Mon Sep 17 00:00:00 2001
From: Ben Brandt <benjamin.j.brandt@gmail.com>
Date: Tue, 19 May 2026 11:55:02 +0200
Subject: [PATCH 020/105] agent_ui: Activate workspace from terminal
 notifications (#57096)

We weren't activating and focusing the right thing before.

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Release Notes:

- N/A
---
 crates/agent_ui/src/agent_panel.rs | 127 ++++++++++++++++++++++++++++-
 1 file changed, 124 insertions(+), 3 deletions(-)

diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs
index 8401b521abd..f13415d0cd5 100644
--- a/crates/agent_ui/src/agent_panel.rs
+++ b/crates/agent_ui/src/agent_panel.rs
@@ -2153,10 +2153,35 @@ impl AgentPanel {
         let event_subscription = cx.subscribe_in(&pop_up, window, {
             move |this, _, event: &AgentNotificationEvent, window, cx| match event {
                 AgentNotificationEvent::Accepted => {
+                    let Some(handle) = window.window_handle().downcast::<MultiWorkspace>() else {
+                        log::error!("root view should be a MultiWorkspace");
+                        return;
+                    };
                     cx.activate(true);
-                    window.activate_window();
-                    this.activate_terminal(terminal_id, true, window, cx);
-                    this.dismiss_terminal_notifications(terminal_id, cx);
+
+                    let workspace = this.workspace.clone();
+                    cx.defer(move |cx| {
+                        handle
+                            .update(cx, |multi_workspace, window, cx| {
+                                window.activate_window();
+
+                                let Some(workspace) = workspace.upgrade() else {
+                                    return;
+                                };
+                                multi_workspace.activate(workspace.clone(), None, window, cx);
+
+                                workspace.update(cx, |workspace, cx| {
+                                    workspace.reveal_panel::<AgentPanel>(window, cx);
+                                    if let Some(panel) = workspace.panel::<AgentPanel>(cx) {
+                                        panel.update(cx, |panel, cx| {
+                                            panel.activate_terminal(terminal_id, true, window, cx);
+                                        });
+                                    }
+                                    workspace.focus_panel::<AgentPanel>(window, cx);
+                                });
+                            })
+                            .log_err();
+                    });
                 }
                 AgentNotificationEvent::Dismissed => {
                     this.dismiss_terminal_notifications(terminal_id, cx);
@@ -7758,6 +7783,102 @@ mod tests {
         });
     }
 
+    #[gpui::test]
+    async fn test_terminal_notification_view_activates_terminal_workspace(cx: &mut TestAppContext) {
+        init_test(cx);
+        cx.update(|cx| {
+            agent::ThreadStore::init_global(cx);
+            language_model::LanguageModelRegistry::test(cx);
+            cx.update_flags(true, vec!["agent-panel-terminal".to_string()]);
+            AgentSettings::override_global(
+                AgentSettings {
+                    notify_when_agent_waiting: NotifyWhenAgentWaiting::PrimaryScreen,
+                    ..AgentSettings::get_global(cx).clone()
+                },
+                cx,
+            );
+        });
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree("/project_a", json!({ "file.txt": "" }))
+            .await;
+        fs.insert_tree("/project_b", json!({ "file.txt": "" }))
+            .await;
+        let project_a = Project::test(fs.clone(), [Path::new("/project_a")], cx).await;
+        let project_b = Project::test(fs, [Path::new("/project_b")], cx).await;
+
+        let multi_workspace =
+            cx.add_window(|window, cx| MultiWorkspace::test_new(project_a.clone(), window, cx));
+        let workspace_a = multi_workspace
+            .read_with(cx, |multi_workspace, _cx| {
+                multi_workspace.workspace().clone()
+            })
+            .unwrap();
+        let workspace_b = multi_workspace
+            .update(cx, |multi_workspace, window, cx| {
+                multi_workspace.test_add_workspace(project_b.clone(), window, cx)
+            })
+            .unwrap();
+
+        let cx = &mut VisualTestContext::from_window(multi_workspace.into(), cx);
+        let panel_a = workspace_a.update_in(cx, |workspace, window, cx| {
+            let panel = cx.new(|cx| AgentPanel::new(workspace, None, window, cx));
+            workspace.add_panel(panel.clone(), window, cx);
+            panel
+        });
+
+        let first_terminal_id = panel_a
+            .update_in(cx, |panel, window, cx| {
+                panel.insert_test_terminal("Build", true, window, cx)
+            })
+            .expect("first test terminal should be inserted");
+        let second_terminal_id = panel_a
+            .update_in(cx, |panel, window, cx| {
+                panel.insert_test_terminal("Server", true, window, cx)
+            })
+            .expect("second test terminal should be inserted");
+        cx.run_until_parked();
+
+        multi_workspace
+            .read_with(cx, |multi_workspace, _cx| {
+                assert_eq!(multi_workspace.workspace(), &workspace_b);
+            })
+            .unwrap();
+        panel_a.read_with(cx, |panel, _cx| {
+            assert_eq!(panel.active_terminal_id(), Some(second_terminal_id));
+        });
+
+        panel_a.update(cx, |panel, cx| {
+            panel.emit_test_terminal_bell(first_terminal_id, cx);
+        });
+        cx.run_until_parked();
+
+        let notification = cx
+            .windows()
+            .iter()
+            .find_map(|window| window.downcast::<AgentNotification>())
+            .expect("terminal bell should show a notification");
+        notification
+            .update(cx, |notification, _window, cx| notification.accept(cx))
+            .unwrap();
+        cx.run_until_parked();
+
+        multi_workspace
+            .read_with(cx, |multi_workspace, _cx| {
+                assert_eq!(multi_workspace.workspace(), &workspace_a);
+            })
+            .unwrap();
+        panel_a.read_with(cx, |panel, cx| {
+            assert_eq!(panel.active_terminal_id(), Some(first_terminal_id));
+            let first_terminal = panel
+                .terminals(cx)
+                .into_iter()
+                .find(|terminal| terminal.id == first_terminal_id)
+                .expect("first terminal should remain in the panel");
+            assert!(!first_terminal.has_notification);
+        });
+    }
+
     #[gpui::test]
     async fn test_running_thread_retained_when_navigating_away(cx: &mut TestAppContext) {
         let (panel, mut cx) = setup_panel(cx).await;

From 85f410004cf583d886dd37f4ffdb7606950678b1 Mon Sep 17 00:00:00 2001
From: Kunall Banerjee <hey@kimchiii.space>
Date: Tue, 19 May 2026 06:05:49 -0400
Subject: [PATCH 021/105] agent_ui: Trigger @-mention menu after opening
 brackets (#55504)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Typing `@` immediately after `(`, `[`, or `{` did not open the Agent
Panel’s @-mention completion menu, so `(@file)`, `[@file]`, and
`{@file}` were unusable. This has been bothering me for quite some time
now. Overall, I believe this is a QoL improvement, albeit a small one.

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [ ] Unsafe blocks (if any) have justifying comments
- [ ] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [ ] Performance impact has been considered and is acceptable

Release Notes:

- Fixed the Agent Panel’s @-mention menu not appearing when `@`
immediately follows `(`, `[`, or `{`.

---------

Co-authored-by: Bennet Bo Fenner <bennetbo@gmx.de>
---
 crates/agent_ui/src/completion_provider.rs | 41 +++++++++++++++++++---
 1 file changed, 37 insertions(+), 4 deletions(-)

diff --git a/crates/agent_ui/src/completion_provider.rs b/crates/agent_ui/src/completion_provider.rs
index 3a4ae6ecc2b..acc08541100 100644
--- a/crates/agent_ui/src/completion_provider.rs
+++ b/crates/agent_ui/src/completion_provider.rs
@@ -1868,10 +1868,11 @@ impl MentionCompletion {
         offset_to_line: usize,
         supported_modes: &[PromptContextType],
     ) -> Option<Self> {
-        // Find the rightmost '@' that has a word boundary before it and no whitespace immediately after
+        // Find the rightmost '@' that has a boundary before it and no whitespace immediately after.
+        // A boundary is the start of the line, whitespace, or an opening bracket.
         let mut last_mention_start = None;
         for (idx, _) in line.rmatch_indices('@') {
-            // No whitespace immediately after '@'
+            // No whitespace immediately after '@'.
             if line[idx + 1..]
                 .chars()
                 .next()
@@ -1880,12 +1881,11 @@ impl MentionCompletion {
                 continue;
             }
 
-            // Must be a word boundary before '@'
             if idx > 0
                 && line[..idx]
                     .chars()
                     .last()
-                    .is_some_and(|c| !c.is_whitespace())
+                    .is_some_and(|c| !c.is_whitespace() && !matches!(c, '(' | '[' | '{'))
             {
                 continue;
             }
@@ -2960,6 +2960,39 @@ mod tests {
             }),
             "Should parse URL ending with @ (even if URL is incomplete)"
         );
+
+        // Bracketed mentions: opening brackets count as a boundary before '@' so
+        // typing `(@`, `[@`, or `{@` still opens the completion menu.
+
+        assert_eq!(
+            MentionCompletion::try_parse("(@", 0, &supported_modes),
+            Some(MentionCompletion {
+                source_range: 1..2,
+                mode: None,
+                argument: None,
+            }),
+            "Should parse mention immediately after '('"
+        );
+
+        assert_eq!(
+            MentionCompletion::try_parse("[@", 0, &supported_modes),
+            Some(MentionCompletion {
+                source_range: 1..2,
+                mode: None,
+                argument: None,
+            }),
+            "Should parse mention immediately after '['"
+        );
+
+        assert_eq!(
+            MentionCompletion::try_parse("{@", 0, &supported_modes),
+            Some(MentionCompletion {
+                source_range: 1..2,
+                mode: None,
+                argument: None,
+            }),
+            "Should parse mention immediately after '{{'"
+        );
     }
 
     #[gpui::test]

From 4557ad7ad12852ffddbe4a25350173197812bdf4 Mon Sep 17 00:00:00 2001
From: Ben Brandt <benjamin.j.brandt@gmail.com>
Date: Tue, 19 May 2026 13:29:00 +0200
Subject: [PATCH 022/105] eval_cli: Initialize themes in eval headless mode
 (#57139)

Also fix patch generation

Release Notes:

- N/A
---
 Cargo.lock                        |  2 ++
 crates/eval_cli/Cargo.toml        |  2 ++
 crates/eval_cli/src/headless.rs   |  1 +
 crates/eval_cli/zed_eval/agent.py | 13 +++++++++----
 4 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 51a1d750fa4..f976aefdf3d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5964,6 +5964,8 @@ dependencies = [
  "settings",
  "shellexpand",
  "terminal_view",
+ "theme",
+ "theme_settings",
  "util",
  "watch",
 ]
diff --git a/crates/eval_cli/Cargo.toml b/crates/eval_cli/Cargo.toml
index cac5dc6aa28..ed1f24d75d2 100644
--- a/crates/eval_cli/Cargo.toml
+++ b/crates/eval_cli/Cargo.toml
@@ -47,5 +47,7 @@ serde_json.workspace = true
 settings.workspace = true
 shellexpand.workspace = true
 terminal_view.workspace = true
+theme.workspace = true
+theme_settings.workspace = true
 util.workspace = true
 watch.workspace = true
diff --git a/crates/eval_cli/src/headless.rs b/crates/eval_cli/src/headless.rs
index a5b86f8eec8..9423f86a312 100644
--- a/crates/eval_cli/src/headless.rs
+++ b/crates/eval_cli/src/headless.rs
@@ -40,6 +40,7 @@ pub fn init(cx: &mut App) -> Arc<AgentCliAppState> {
 
     let settings_store = SettingsStore::new(cx, &settings::default_settings());
     cx.set_global(settings_store);
+    theme_settings::init(theme::LoadThemes::JustBase, cx);
 
     let user_agent = format!(
         "Zed Agent CLI/{} ({}; {})",
diff --git a/crates/eval_cli/zed_eval/agent.py b/crates/eval_cli/zed_eval/agent.py
index 4543dd9497d..4720a7dbc13 100644
--- a/crates/eval_cli/zed_eval/agent.py
+++ b/crates/eval_cli/zed_eval/agent.py
@@ -443,16 +443,21 @@ class ZedAgent(BaseInstalledAgent):
             env=env,
         )
 
-        # Only generate a patch if the workdir is a git repo
-        # (SWE-bench style). Terminal-bench containers aren't git repos.
+        # Only generate a patch if the workdir is a git repo with a valid HEAD
+        # (SWE-bench style). Terminal-bench containers aren't git repos, and
+        # some harnesses mount an initialized repo before creating the first commit.
         await self.exec_as_agent(
             environment,
             command=(
-                'if [ -d ".git" ]; then '
+                "if git rev-parse --git-dir >/dev/null 2>&1; then "
                 "git add -A && "
-                "git diff --cached HEAD > /logs/agent/patch.diff && "
+                "if git rev-parse --verify HEAD >/dev/null 2>&1; then "
+                "git diff --cached HEAD -- > /logs/agent/patch.diff && "
                 'echo "Patch size: $(wc -c < /logs/agent/patch.diff) bytes"; '
                 "else "
+                'echo "Git repo has no valid HEAD, skipping patch generation"; '
+                "fi; "
+                "else "
                 'echo "No git repo found, skipping patch generation"; '
                 "fi"
             ),

From 46b08f9d7d6f68875cee692f4ae88c902a05ab4a Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Tue, 19 May 2026 05:46:05 -0600
Subject: [PATCH 023/105] gpui: Trim trailing whitespace and punctuation before
 ellipsis (#57106)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When truncating text at the end with an ellipsis, the truncation point
can land right after a space or punctuation character, producing results
like `"some text …"` or `"some text-…"`.

This trims trailing whitespace and ASCII punctuation from the truncated
prefix before appending the ellipsis affix, so you get clean results
like `"some text…"` instead.

Release Notes:

- Improved text truncation to avoid trailing spaces or punctuation
before the ellipsis.
---
 crates/gpui/src/text_system/line_wrapper.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/crates/gpui/src/text_system/line_wrapper.rs b/crates/gpui/src/text_system/line_wrapper.rs
index 67e4a971344..0524bad84f0 100644
--- a/crates/gpui/src/text_system/line_wrapper.rs
+++ b/crates/gpui/src/text_system/line_wrapper.rs
@@ -201,9 +201,11 @@ impl LineWrapper {
                     "{truncation_affix}{}",
                     &line[line.ceil_char_boundary(truncate_ix + 1)..]
                 )),
-                TruncateFrom::End => {
-                    SharedString::from(format!("{}{truncation_affix}", &line[..truncate_ix]))
-                }
+                TruncateFrom::End => SharedString::from(format!(
+                    "{}{truncation_affix}",
+                    line[..truncate_ix]
+                        .trim_end_matches(|c: char| c.is_whitespace() || c.is_ascii_punctuation())
+                )),
             };
             let mut runs = runs.to_vec();
             update_runs_after_truncation(&result, truncation_affix, &mut runs, truncate_from);

From c352cad16946d9685d580ae0381984247526e1e2 Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Tue, 19 May 2026 14:29:35 +0200
Subject: [PATCH 024/105] agent: Replay image output (#57143)

Release Notes:

- agent: Fix image output from tools not being reloaded when restoring
thread
---
 crates/agent/src/thread.rs | 188 +++++++++++++++++++++++++++++++++++--
 1 file changed, 180 insertions(+), 8 deletions(-)

diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rs
index ae5c5510764..55d7b62b99b 100644
--- a/crates/agent/src/thread.rs
+++ b/crates/agent/src/thread.rs
@@ -1215,10 +1215,10 @@ impl Thread {
         stream: &ThreadEventStream,
         cx: &mut Context<Self>,
     ) {
-        // Extract saved output and status first, so they're available even if tool is not found
         let output = tool_result
             .as_ref()
             .and_then(|result| result.output.clone());
+        let replay_content = tool_result.and_then(Self::tool_result_content_for_replay);
         let status = tool_result
             .as_ref()
             .map_or(acp::ToolCallStatus::Failed, |result| {
@@ -1255,13 +1255,13 @@ impl Thread {
                         .raw_input(tool_use.input.clone()),
                 )))
                 .ok();
-            stream.update_tool_call_fields(
-                &tool_use.id,
-                acp::ToolCallUpdateFields::new()
-                    .status(status)
-                    .raw_output(output),
-                None,
-            );
+            let mut fields = acp::ToolCallUpdateFields::new()
+                .status(status)
+                .raw_output(output);
+            if let Some(content) = replay_content {
+                fields = fields.content(content);
+            }
+            stream.update_tool_call_fields(&tool_use.id, fields, None);
             return;
         };
 
@@ -1275,6 +1275,14 @@ impl Thread {
             tool_use.input.clone(),
         );
 
+        if let Some(content) = replay_content {
+            stream.update_tool_call_fields(
+                &tool_use.id,
+                acp::ToolCallUpdateFields::new().content(content),
+                None,
+            );
+        }
+
         if let Some(output) = output.clone() {
             // For replay, we use a dummy cancellation receiver since the tool already completed
             let (_cancellation_tx, cancellation_rx) = watch::channel(false);
@@ -1297,6 +1305,45 @@ impl Thread {
         );
     }
 
+    fn tool_result_content_for_replay(
+        tool_result: &LanguageModelToolResult,
+    ) -> Option<Vec<acp::ToolCallContent>> {
+        let has_image = tool_result
+            .content
+            .iter()
+            .any(|part| matches!(part, LanguageModelToolResultContent::Image(_)));
+        if !has_image && tool_result.output.is_some() {
+            return None;
+        }
+
+        let content = tool_result
+            .content
+            .iter()
+            .filter_map(|part| match part {
+                LanguageModelToolResultContent::Text(text) => {
+                    if text.is_empty() {
+                        None
+                    } else {
+                        Some(acp::ToolCallContent::Content(acp::Content::new(
+                            acp::ContentBlock::Text(acp::TextContent::new(text.to_string())),
+                        )))
+                    }
+                }
+                LanguageModelToolResultContent::Image(image) => Some(
+                    acp::ToolCallContent::Content(acp::Content::new(acp::ContentBlock::Image(
+                        acp::ImageContent::new(image.source.clone(), "image/png"),
+                    ))),
+                ),
+            })
+            .collect::<Vec<_>>();
+
+        if content.is_empty() {
+            None
+        } else {
+            Some(content)
+        }
+    }
+
     pub fn from_db(
         id: acp::SessionId,
         db_thread: DbThread,
@@ -4454,6 +4501,131 @@ mod tests {
         })
     }
 
+    struct ReplayImageTool;
+
+    impl AgentTool for ReplayImageTool {
+        type Input = ();
+        type Output = String;
+
+        const NAME: &'static str = "registered_image_tool";
+
+        fn kind() -> acp::ToolKind {
+            acp::ToolKind::Other
+        }
+
+        fn initial_title(
+            &self,
+            _input: Result<Self::Input, serde_json::Value>,
+            _cx: &mut App,
+        ) -> SharedString {
+            "Registered Image Tool".into()
+        }
+
+        fn run(
+            self: Arc<Self>,
+            _input: ToolInput<Self::Input>,
+            _event_stream: ToolCallEventStream,
+            _cx: &mut App,
+        ) -> Task<Result<Self::Output, Self::Output>> {
+            Task::ready(Ok(String::new()))
+        }
+    }
+
+    #[gpui::test]
+    async fn test_replay_tool_call_replays_image_content(cx: &mut TestAppContext) {
+        let (thread, _event_stream) = setup_thread_for_test(cx).await;
+
+        let registered_tool_use_id = LanguageModelToolUseId::from("registered_tool_id");
+        let missing_tool_use_id = LanguageModelToolUseId::from("missing_tool_id");
+        let image_data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR4nGP4z8DwHwAFAAH/iZk9HQAAAABJRU5ErkJggg==";
+        let image = LanguageModelImage {
+            source: image_data.into(),
+        };
+
+        let mut replay_events = cx.update(|cx| {
+            thread.update(cx, |thread, cx| {
+                thread.add_tool(ReplayImageTool);
+
+                let registered_tool_use = LanguageModelToolUse {
+                    id: registered_tool_use_id.clone(),
+                    name: ReplayImageTool::NAME.into(),
+                    raw_input: "null".to_string(),
+                    input: json!(null),
+                    is_input_complete: true,
+                    thought_signature: None,
+                };
+                let missing_tool_use = LanguageModelToolUse {
+                    id: missing_tool_use_id.clone(),
+                    name: "missing_image_tool".into(),
+                    raw_input: "{}".to_string(),
+                    input: json!({}),
+                    is_input_complete: true,
+                    thought_signature: None,
+                };
+
+                let mut tool_results = IndexMap::default();
+                tool_results.insert(
+                    registered_tool_use_id.clone(),
+                    LanguageModelToolResult {
+                        tool_use_id: registered_tool_use_id.clone(),
+                        tool_name: ReplayImageTool::NAME.into(),
+                        is_error: false,
+                        content: vec![
+                            LanguageModelToolResultContent::Text("before".into()),
+                            LanguageModelToolResultContent::Image(image.clone()),
+                            LanguageModelToolResultContent::Text("after".into()),
+                        ],
+                        output: Some(json!("raw output")),
+                    },
+                );
+                tool_results.insert(
+                    missing_tool_use_id.clone(),
+                    LanguageModelToolResult {
+                        tool_use_id: missing_tool_use_id.clone(),
+                        tool_name: "missing_image_tool".into(),
+                        is_error: false,
+                        content: vec![LanguageModelToolResultContent::Image(image.clone())],
+                        output: Some(json!("raw output")),
+                    },
+                );
+
+                thread.messages.push(Message::Agent(AgentMessage {
+                    content: vec![
+                        AgentMessageContent::ToolUse(registered_tool_use),
+                        AgentMessageContent::ToolUse(missing_tool_use),
+                    ],
+                    tool_results,
+                    reasoning_details: None,
+                }));
+
+                thread.replay(cx)
+            })
+        });
+
+        let mut tool_use_ids_with_image_content = HashSet::default();
+        while let Some(event) = replay_events.next().await {
+            let event = event.unwrap();
+            if let ThreadEvent::ToolCallUpdate(acp_thread::ToolCallUpdate::UpdateFields(update)) =
+                event
+                && let Some(content) = &update.fields.content
+                && content.iter().any(|content| {
+                    matches!(
+                        content,
+                        acp::ToolCallContent::Content(acp::Content {
+                            content: acp::ContentBlock::Image(_),
+                            ..
+                        })
+                    )
+                })
+            {
+                tool_use_ids_with_image_content.insert(update.tool_call_id.to_string());
+            }
+        }
+
+        assert!(tool_use_ids_with_image_content.contains(&registered_tool_use_id.to_string()));
+        assert!(tool_use_ids_with_image_content.contains(&missing_tool_use_id.to_string()));
+    }
+
     #[gpui::test]
     async fn test_set_model_propagates_to_subagents(cx: &mut TestAppContext) {
         let (parent, _event_stream) = setup_thread_for_test(cx).await;

From da43bdb648202474bc7402590f0d6042a62c6ba2 Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Tue, 19 May 2026 14:51:42 +0200
Subject: [PATCH 025/105] agent: Support image output from MCP tools (#57134)

Release Notes:

- agent: Support image output from MCP tools
---
 crates/agent/src/tests/mod.rs                 |  25 +-
 .../src/tools/context_server_registry.rs      |  47 +++-
 .../src/conversation_view/thread_view.rs      |  44 ++--
 crates/language_model/src/request.rs          | 230 +++++++++++-------
 crates/language_model_core/src/request.rs     |   1 -
 5 files changed, 225 insertions(+), 122 deletions(-)

diff --git a/crates/agent/src/tests/mod.rs b/crates/agent/src/tests/mod.rs
index 7713907f893..9592d8f7928 100644
--- a/crates/agent/src/tests/mod.rs
+++ b/crates/agent/src/tests/mod.rs
@@ -26,10 +26,10 @@ use gpui::{
 use indoc::indoc;
 use language_model::{
     CompletionIntent, LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent,
-    LanguageModelId, LanguageModelProviderId, LanguageModelProviderName, LanguageModelRegistry,
-    LanguageModelRequest, LanguageModelRequestMessage, LanguageModelToolResult,
-    LanguageModelToolSchemaFormat, LanguageModelToolUse, MessageContent, Role, StopReason,
-    TokenUsage,
+    LanguageModelId, LanguageModelImageExt, LanguageModelProviderId, LanguageModelProviderName,
+    LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
+    LanguageModelToolResult, LanguageModelToolSchemaFormat, LanguageModelToolUse, MessageContent,
+    Role, StopReason, TokenUsage,
     fake_provider::{FakeLanguageModel, FakeLanguageModelProvider},
 };
 use pretty_assertions::assert_eq;
@@ -1656,6 +1656,7 @@ async fn test_mcp_tool_multi_content_response(cx: &mut TestAppContext) {
 
     let (tool_call_params, tool_call_response) = mcp_tool_calls.next().await.unwrap();
     assert_eq!(tool_call_params.name, "screenshot");
+    let image_data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR4nGP4z8DwHwAFAAH/iZk9HQAAAABJRU5ErkJggg==";
     tool_call_response
         .send(context_server::types::CallToolResponse {
             content: vec![
@@ -1663,7 +1664,7 @@ async fn test_mcp_tool_multi_content_response(cx: &mut TestAppContext) {
                     text: "Some text".into(),
                 },
                 context_server::types::ToolResponseContent::Image {
-                    data: "aGVsbG8=".into(),
+                    data: image_data.into(),
                     mime_type: "image/png".into(),
                 },
                 context_server::types::ToolResponseContent::Text {
@@ -1691,13 +1692,25 @@ async fn test_mcp_tool_multi_content_response(cx: &mut TestAppContext) {
         })
         .expect("expected a tool result");
     assert_eq!(tool_result.tool_use_id, "tool_1".into());
-    assert_eq!(tool_result.content.len(), 2);
+    assert_eq!(tool_result.content.len(), 3);
+    assert_eq!(
+        tool_result.content[0],
+        language_model::LanguageModelToolResultContent::Text(Arc::from("Some text"))
+    );
+    let expected_image =
+        language_model::LanguageModelImage::from_base64_image(image_data, "image/png")
+            .expect("image conversion should not error")
+            .expect("image conversion should succeed");
     assert_eq!(
         tool_result.content[0],
         language_model::LanguageModelToolResultContent::Text(Arc::from("Some text"))
     );
     assert_eq!(
         tool_result.content[1],
+        language_model::LanguageModelToolResultContent::Image(expected_image)
+    );
+    assert_eq!(
+        tool_result.content[2],
         language_model::LanguageModelToolResultContent::Text(Arc::from("Some more text"))
     );
     fake_model.end_last_completion_stream();
diff --git a/crates/agent/src/tools/context_server_registry.rs b/crates/agent/src/tools/context_server_registry.rs
index 01601679c90..6c0e8d31557 100644
--- a/crates/agent/src/tools/context_server_registry.rs
+++ b/crates/agent/src/tools/context_server_registry.rs
@@ -5,7 +5,7 @@ use collections::{BTreeMap, HashMap};
 use context_server::{ContextServerId, client::NotificationSubscription};
 use futures::FutureExt as _;
 use gpui::{App, AppContext, AsyncApp, Context, Entity, EventEmitter, SharedString, Task};
-use language_model::LanguageModelToolResultContent;
+use language_model::{LanguageModelImage, LanguageModelImageExt, LanguageModelToolResultContent};
 use project::context_server_store::{ContextServerStatus, ContextServerStore};
 use std::sync::Arc;
 use util::ResultExt;
@@ -346,7 +346,7 @@ impl AnyAgentTool for ContextServerTool {
         let authorize =
             event_stream.authorize_third_party_tool(initial_title, tool_id, display_name, cx);
 
-        cx.spawn(async move |_cx| {
+        cx.spawn(async move |cx| {
             let input = input
                 .recv()
                 .await
@@ -394,15 +394,50 @@ impl AnyAgentTool for ContextServerTool {
             }
 
             let mut llm_output = Vec::new();
+            let mut tool_call_content = Vec::new();
             let mut concatenated_text = String::new();
             for content in response.content {
                 match content {
                     context_server::types::ToolResponseContent::Text { text } => {
                         concatenated_text.push_str(&text);
+                        tool_call_content.push(acp::ToolCallContent::Content(acp::Content::new(
+                            acp::ContentBlock::Text(acp::TextContent::new(text.clone())),
+                        )));
                         llm_output.push(LanguageModelToolResultContent::Text(text.into()));
                     }
-                    context_server::types::ToolResponseContent::Image { .. } => {
-                        log::warn!("Ignoring image content from tool response");
+                    context_server::types::ToolResponseContent::Image { data, mime_type } => {
+                        tool_call_content.push(acp::ToolCallContent::Content(acp::Content::new(
+                            acp::ContentBlock::Image(acp::ImageContent::new(
+                                data.clone(),
+                                mime_type.clone(),
+                            )),
+                        )));
+                        let language_model_image = cx
+                            .background_spawn({
+                                let mime_type = mime_type.clone();
+                                async move {
+                                    LanguageModelImage::from_base64_image(&data, &mime_type)
+                                }
+                            })
+                            .await;
+                        match language_model_image {
+                            Ok(Some(image)) => {
+                                llm_output.push(LanguageModelToolResultContent::Image(image));
+                            }
+                            Ok(None) => {
+                                log::warn!(
+                                    "Skipping MCP tool response image with MIME type `{}` because it cannot be converted for language model input",
+                                    mime_type
+                                );
+                            }
+                            Err(error) => {
+                                log::warn!(
+                                    "Failed to convert MCP tool response image with MIME type `{}` for language model input: {:#}",
+                                    mime_type,
+                                    error
+                                );
+                            }
+                        }
                     }
                     context_server::types::ToolResponseContent::Audio { .. } => {
                         log::warn!("Ignoring audio content from tool response");
@@ -415,6 +450,10 @@ impl AnyAgentTool for ContextServerTool {
                     }
                 }
             }
+            if !tool_call_content.is_empty() {
+                event_stream
+                    .update_fields(acp::ToolCallUpdateFields::new().content(tool_call_content));
+            }
             let raw_output = serde_json::Value::String(concatenated_text);
             Ok(AgentToolOutput {
                 raw_output,
diff --git a/crates/agent_ui/src/conversation_view/thread_view.rs b/crates/agent_ui/src/conversation_view/thread_view.rs
index 6b63abd50ea..bb8d65fa868 100644
--- a/crates/agent_ui/src/conversation_view/thread_view.rs
+++ b/crates/agent_ui/src/conversation_view/thread_view.rs
@@ -6585,6 +6585,32 @@ impl ThreadView {
                                 )
                             }),
                     )
+                    .when(!use_card_layout, |this| {
+                        let button_id =
+                            SharedString::from(format!("tool_output-collapse-{:?}", tool_call.id));
+                        let tool_call_id = tool_call.id.clone();
+
+                        this.child(
+                            div()
+                                .ml(rems(0.4))
+                                .px_3p5()
+                                .pt_2()
+                                .border_l_1()
+                                .border_color(self.tool_card_border_color(cx))
+                                .child(
+                                    IconButton::new(button_id, IconName::ChevronUp)
+                                        .full_width()
+                                        .style(ButtonStyle::Outlined)
+                                        .icon_color(Color::Muted)
+                                        .on_click(cx.listener({
+                                            move |this: &mut Self, _, _, cx: &mut Context<Self>| {
+                                                this.expanded_tool_calls.remove(&tool_call_id);
+                                                cx.notify();
+                                            }
+                                        })),
+                                ),
+                        )
+                    })
                     .into_any(),
                 ToolCallStatus::Rejected => Empty.into_any(),
             }
@@ -7580,7 +7606,6 @@ impl ThreadView {
                 } else if let Some(markdown) = content.markdown() {
                     self.render_markdown_output(
                         markdown.clone(),
-                        tool_call.id.clone(),
                         context_ix,
                         card_layout,
                         window,
@@ -7724,14 +7749,11 @@ impl ThreadView {
     fn render_markdown_output(
         &self,
         markdown: Entity<Markdown>,
-        tool_call_id: acp::ToolCallId,
         context_ix: usize,
         card_layout: bool,
         window: &Window,
         cx: &Context<Self>,
     ) -> AnyElement {
-        let button_id = SharedString::from(format!("tool_output-{:?}", tool_call_id));
-
         v_flex()
             .gap_2()
             .map(|this| {
@@ -7754,20 +7776,6 @@ impl ThreadView {
                 MarkdownStyle::themed(MarkdownFont::Agent, window, cx),
                 cx,
             ))
-            .when(!card_layout, |this| {
-                this.child(
-                    IconButton::new(button_id, IconName::ChevronUp)
-                        .full_width()
-                        .style(ButtonStyle::Outlined)
-                        .icon_color(Color::Muted)
-                        .on_click(cx.listener({
-                            move |this: &mut Self, _, _, cx: &mut Context<Self>| {
-                                this.expanded_tool_calls.remove(&tool_call_id);
-                                cx.notify();
-                            }
-                        })),
-                )
-            })
             .into_any_element()
     }
 
diff --git a/crates/language_model/src/request.rs b/crates/language_model/src/request.rs
index edb5645a8d1..b4dedbbd7ba 100644
--- a/crates/language_model/src/request.rs
+++ b/crates/language_model/src/request.rs
@@ -1,8 +1,8 @@
 use std::io::{Cursor, Write};
 use std::sync::Arc;
 
-use anyhow::Result;
-use base64::write::EncoderWriter;
+use anyhow::{Result, anyhow};
+use base64::{Engine as _, write::EncoderWriter};
 use gpui::{
     App, AppContext as _, DevicePixels, Image, ImageFormat, ObjectFit, Size, Task, point, px, size,
 };
@@ -29,6 +29,7 @@ const MAX_IMAGE_DOWNSCALE_PASSES: usize = 8;
 pub trait LanguageModelImageExt {
     const FORMAT: ImageFormat;
     fn from_image(data: Arc<Image>, cx: &mut App) -> Task<Option<LanguageModelImage>>;
+    fn from_base64_image(data: &str, mime_type: &str) -> Result<Option<LanguageModelImage>>;
 }
 
 impl LanguageModelImageExt for LanguageModelImage {
@@ -36,93 +37,104 @@ impl LanguageModelImageExt for LanguageModelImage {
 
     fn from_image(data: Arc<Image>, cx: &mut App) -> Task<Option<LanguageModelImage>> {
         cx.background_spawn(async move {
-            let image_bytes = Cursor::new(data.bytes());
-            let dynamic_image = match data.format() {
-                ImageFormat::Png => image::codecs::png::PngDecoder::new(image_bytes)
-                    .and_then(image::DynamicImage::from_decoder),
-                ImageFormat::Jpeg => image::codecs::jpeg::JpegDecoder::new(image_bytes)
-                    .and_then(image::DynamicImage::from_decoder),
-                ImageFormat::Webp => image::codecs::webp::WebPDecoder::new(image_bytes)
-                    .and_then(image::DynamicImage::from_decoder),
-                ImageFormat::Gif => image::codecs::gif::GifDecoder::new(image_bytes)
-                    .and_then(image::DynamicImage::from_decoder),
-                ImageFormat::Bmp => image::codecs::bmp::BmpDecoder::new(image_bytes)
-                    .and_then(image::DynamicImage::from_decoder),
-                ImageFormat::Tiff => image::codecs::tiff::TiffDecoder::new(image_bytes)
-                    .and_then(image::DynamicImage::from_decoder),
-                _ => return None,
-            }
-            .log_err()?;
-
-            let width = dynamic_image.width();
-            let height = dynamic_image.height();
-            let image_size = size(DevicePixels(width as i32), DevicePixels(height as i32));
-
-            // First apply any provider-specific dimension constraints we know about (Anthropic).
-            let mut processed_image = if image_size.width.0 > ANTHROPIC_SIZE_LIMIT as i32
-                || image_size.height.0 > ANTHROPIC_SIZE_LIMIT as i32
-            {
-                let new_bounds = ObjectFit::ScaleDown.get_bounds(
-                    gpui::Bounds {
-                        origin: point(px(0.0), px(0.0)),
-                        size: size(px(ANTHROPIC_SIZE_LIMIT), px(ANTHROPIC_SIZE_LIMIT)),
-                    },
-                    image_size,
-                );
-                dynamic_image.resize(
-                    new_bounds.size.width.into(),
-                    new_bounds.size.height.into(),
-                    image::imageops::FilterType::Triangle,
-                )
-            } else {
-                dynamic_image
+            let format = match data.format() {
+                ImageFormat::Png => image::ImageFormat::Png,
+                ImageFormat::Jpeg => image::ImageFormat::Jpeg,
+                ImageFormat::Webp => image::ImageFormat::WebP,
+                ImageFormat::Gif => image::ImageFormat::Gif,
+                ImageFormat::Bmp => image::ImageFormat::Bmp,
+                ImageFormat::Tiff => image::ImageFormat::Tiff,
+                ImageFormat::Ico => image::ImageFormat::Ico,
+                ImageFormat::Pnm => image::ImageFormat::Pnm,
+                ImageFormat::Svg => return None,
             };
-
-            // Then enforce a default per-image size cap on the encoded PNG bytes.
-            //
-            // We always send PNG bytes (either original PNG bytes, or re-encoded PNG) base64'd.
-            // The upstream provider limit we want to respect is effectively on the binary image
-            // payload size, so we enforce against the encoded PNG bytes before base64 encoding.
-            let mut encoded_png = encode_png_bytes(&processed_image).log_err()?;
-            for _pass in 0..MAX_IMAGE_DOWNSCALE_PASSES {
-                if encoded_png.len() <= DEFAULT_IMAGE_MAX_BYTES {
-                    break;
-                }
-
-                // Scale down geometrically to converge quickly. We don't know the final PNG size
-                // as a function of pixels, so we iteratively shrink.
-                let (w, h) = processed_image.dimensions();
-                if w <= 1 || h <= 1 {
-                    break;
-                }
-
-                // Shrink by ~15% each pass (0.85). This is a compromise between speed and
-                // preserving image detail.
-                let new_w = ((w as f32) * 0.85).round().max(1.0) as u32;
-                let new_h = ((h as f32) * 0.85).round().max(1.0) as u32;
-
-                processed_image =
-                    processed_image.resize(new_w, new_h, image::imageops::FilterType::Triangle);
-                encoded_png = encode_png_bytes(&processed_image).log_err()?;
-            }
-
-            if encoded_png.len() > DEFAULT_IMAGE_MAX_BYTES {
-                // Still too large after multiple passes; treat as non-convertible for now.
-                // (Provider-specific handling can be introduced later.)
-                return None;
-            }
-
-            // Now base64 encode the PNG bytes.
-            let base64_image = encode_bytes_as_base64(encoded_png.as_slice()).log_err()?;
-
-            // SAFETY: The base64 encoder should not produce non-UTF8.
-            let source = unsafe { String::from_utf8_unchecked(base64_image) };
-
-            Some(LanguageModelImage {
-                source: source.into(),
-            })
+            let dynamic_image =
+                image::load_from_memory_with_format(data.bytes(), format).log_err()?;
+            language_model_image_from_dynamic_image(dynamic_image)
+                .log_err()
+                .flatten()
         })
     }
+
+    fn from_base64_image(data: &str, mime_type: &str) -> Result<Option<LanguageModelImage>> {
+        let format = image::ImageFormat::from_mime_type(mime_type)
+            .ok_or_else(|| anyhow!("unsupported image MIME type `{}`", mime_type))?;
+        let bytes = base64::engine::general_purpose::STANDARD.decode(data.as_bytes())?;
+        let dynamic_image = image::load_from_memory_with_format(&bytes, format)?;
+        language_model_image_from_dynamic_image(dynamic_image)
+    }
+}
+
+fn language_model_image_from_dynamic_image(
+    dynamic_image: image::DynamicImage,
+) -> Result<Option<LanguageModelImage>> {
+    let width = dynamic_image.width();
+    let height = dynamic_image.height();
+    let image_size = size(DevicePixels(width as i32), DevicePixels(height as i32));
+
+    // First apply any provider-specific dimension constraints we know about (Anthropic).
+    let mut processed_image = if image_size.width.0 > ANTHROPIC_SIZE_LIMIT as i32
+        || image_size.height.0 > ANTHROPIC_SIZE_LIMIT as i32
+    {
+        let new_bounds = ObjectFit::ScaleDown.get_bounds(
+            gpui::Bounds {
+                origin: point(px(0.0), px(0.0)),
+                size: size(px(ANTHROPIC_SIZE_LIMIT), px(ANTHROPIC_SIZE_LIMIT)),
+            },
+            image_size,
+        );
+        dynamic_image.resize(
+            new_bounds.size.width.into(),
+            new_bounds.size.height.into(),
+            image::imageops::FilterType::Triangle,
+        )
+    } else {
+        dynamic_image
+    };
+
+    // Then enforce a default per-image size cap on the encoded PNG bytes.
+    //
+    // We always send PNG bytes (either original PNG bytes, or re-encoded PNG) base64'd.
+    // The upstream provider limit we want to respect is effectively on the binary image
+    // payload size, so we enforce against the encoded PNG bytes before base64 encoding.
+    let mut encoded_png = encode_png_bytes(&processed_image)?;
+    for _pass in 0..MAX_IMAGE_DOWNSCALE_PASSES {
+        if encoded_png.len() <= DEFAULT_IMAGE_MAX_BYTES {
+            break;
+        }
+
+        // Scale down geometrically to converge quickly. We don't know the final PNG size
+        // as a function of pixels, so we iteratively shrink.
+        let (width, height) = processed_image.dimensions();
+        if width <= 1 || height <= 1 {
+            break;
+        }
+
+        // Shrink by ~15% each pass (0.85). This is a compromise between speed and
+        // preserving image detail.
+        let new_width = ((width as f32) * 0.85).round().max(1.0) as u32;
+        let new_height = ((height as f32) * 0.85).round().max(1.0) as u32;
+
+        processed_image =
+            processed_image.resize(new_width, new_height, image::imageops::FilterType::Triangle);
+        encoded_png = encode_png_bytes(&processed_image)?;
+    }
+
+    if encoded_png.len() > DEFAULT_IMAGE_MAX_BYTES {
+        // Still too large after multiple passes; treat as non-convertible for now.
+        // (Provider-specific handling can be introduced later.)
+        return Ok(None);
+    }
+
+    // Now base64 encode the PNG bytes.
+    let base64_image = encode_bytes_as_base64(encoded_png.as_slice())?;
+
+    // SAFETY: The base64 encoder should not produce non-UTF8.
+    let source = unsafe { String::from_utf8_unchecked(base64_image) };
+
+    Ok(Some(LanguageModelImage {
+        source: source.into(),
+    }))
 }
 
 fn encode_png_bytes(image: &image::DynamicImage) -> Result<Vec<u8>> {
@@ -162,7 +174,6 @@ pub fn gpui_size_to_image_size(size: Size<DevicePixels>) -> ImageSize {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use base64::Engine as _;
     use gpui::TestAppContext;
 
     fn base64_to_png_bytes(base64: &str) -> Vec<u8> {
@@ -202,13 +213,46 @@ mod tests {
             raw_png.len()
         );
 
-        let image = Arc::new(gpui::Image::from_bytes(ImageFormat::Png, raw_png));
+        let image = Arc::new(gpui::Image::from_bytes(ImageFormat::Png, raw_png.clone()));
         let lm_image = cx
             .update(|cx| LanguageModelImage::from_image(Arc::clone(&image), cx))
             .await
             .expect("from_image should succeed");
 
-        let decoded_png = base64_to_png_bytes(lm_image.source.as_ref());
+        assert_downscaled_from_original(lm_image.source.as_ref(), 4096, 4096);
+
+        let base64_png = base64::engine::general_purpose::STANDARD.encode(raw_png);
+        let lm_image = LanguageModelImage::from_base64_image(&base64_png, "image/png")
+            .expect("from_base64_image should not error")
+            .expect("from_base64_image should succeed");
+
+        assert_downscaled_from_original(lm_image.source.as_ref(), 4096, 4096);
+    }
+
+    #[test]
+    fn test_from_base64_image_converts_jpeg_to_png() {
+        use image::ImageEncoder as _;
+
+        let mut jpeg_bytes = Vec::new();
+        image::codecs::jpeg::JpegEncoder::new(&mut jpeg_bytes)
+            .write_image(&[255, 0, 0], 1, 1, image::ExtendedColorType::Rgb8)
+            .expect("encode jpeg");
+        let jpeg_data = base64::engine::general_purpose::STANDARD.encode(jpeg_bytes);
+
+        let image = LanguageModelImage::from_base64_image(&jpeg_data, "image/jpeg")
+            .expect("from_base64_image should not error")
+            .expect("from_base64_image should succeed");
+        let png_bytes = base64_to_png_bytes(image.source.as_ref());
+
+        assert_eq!(
+            image::guess_format(&png_bytes).expect("guess image format"),
+            image::ImageFormat::Png
+        );
+        assert_eq!(png_dimensions(&png_bytes), (1, 1));
+    }
+
+    fn assert_downscaled_from_original(base64_png: &str, width: u32, height: u32) {
+        let decoded_png = base64_to_png_bytes(base64_png);
         assert!(
             decoded_png.len() <= DEFAULT_IMAGE_MAX_BYTES,
             "Encoded PNG should be ≤ {} bytes after downscale, but was {} bytes",
@@ -216,12 +260,12 @@ mod tests {
             decoded_png.len()
         );
 
-        let (w, h) = png_dimensions(&decoded_png);
+        let (downsized_width, downsized_height) = png_dimensions(&decoded_png);
         assert!(
-            w < 4096 && h < 4096,
+            downsized_width < width && downsized_height < height,
             "Dimensions should have shrunk: got {}×{}",
-            w,
-            h
+            downsized_width,
+            downsized_height
         );
     }
 }
diff --git a/crates/language_model_core/src/request.rs b/crates/language_model_core/src/request.rs
index 7f8f7c7d764..19a642ba01b 100644
--- a/crates/language_model_core/src/request.rs
+++ b/crates/language_model_core/src/request.rs
@@ -438,7 +438,6 @@ mod tests {
         // Test image object
         let json = serde_json::json!({
             "source": "base64encodedimagedata",
-            "size": {"width": 100, "height": 200}
         });
         let content: LanguageModelToolResultContent = serde_json::from_value(json).unwrap();
         match content {

From 3a821765e51b2cb3d4764ecafbbbbd6acbff5923 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Tue, 19 May 2026 10:28:45 -0300
Subject: [PATCH 026/105] icons: Update some icon SVGs (#57151)

Just some house-keeping here, aligning and fixing size on some SVGs.

Release Notes:

- N/A
---
 assets/icons/acp_registry.svg      |  6 +++---
 assets/icons/ai_lm_studio.svg      | 26 +++++++++++++-------------
 assets/icons/ai_ollama.svg         | 10 +++++-----
 assets/icons/ai_open_ai.svg        |  2 +-
 assets/icons/ai_x_ai.svg           |  2 +-
 assets/icons/ai_zed.svg            |  2 +-
 assets/icons/editor_atom.svg       |  2 +-
 assets/icons/editor_cursor.svg     |  2 +-
 assets/icons/editor_emacs.svg      | 12 +++++-------
 assets/icons/editor_jet_brains.svg |  2 +-
 assets/icons/editor_sublime.svg    |  6 +++---
 assets/icons/editor_vs_code.svg    |  2 +-
 assets/icons/share.svg             |  5 +++++
 crates/icons/src/icons.rs          |  1 +
 14 files changed, 42 insertions(+), 38 deletions(-)
 create mode 100644 assets/icons/share.svg

diff --git a/assets/icons/acp_registry.svg b/assets/icons/acp_registry.svg
index fb64ea6fbcf..d98728fbbd0 100644
--- a/assets/icons/acp_registry.svg
+++ b/assets/icons/acp_registry.svg
@@ -1,4 +1,4 @@
-<svg width="12" height="12" viewBox="0 0 12 12" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path opacity="0.3" d="M9 1.5H3C2.17157 1.5 1.5 2.17157 1.5 3V9C1.5 9.82843 2.17157 10.5 3 10.5H9C9.82843 10.5 10.5 9.82843 10.5 9V3C10.5 2.17157 9.82843 1.5 9 1.5Z" stroke="#C6CAD0" stroke-width="0.9"/>
-<path d="M4.32058 8.53711C3.99873 8.53711 3.79672 8.34879 3.79672 8.05092C3.79672 7.96532 3.82069 7.84891 3.8652 7.72222L5.21422 4.04838C5.35802 3.64778 5.60112 3.46289 5.99144 3.46289C6.39546 3.46289 6.63514 3.64093 6.78236 4.04495L8.13823 7.72222C8.18616 7.85575 8.20328 7.9482 8.20328 8.05092C8.20328 8.3351 7.98758 8.53711 7.68627 8.53711C7.39524 8.53711 7.24117 8.40358 7.14872 8.08173L6.8885 7.30108H5.10465L4.84444 8.07146C4.74857 8.40015 4.59449 8.53711 4.32058 8.53711ZM5.33063 6.49989H6.64883L5.99487 4.47636H5.9709L5.33063 6.49989Z" fill="#C6CAD0"/>
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M5.76074 11.3828C5.3316 11.3828 5.06226 11.1317 5.06226 10.7346C5.06226 10.6204 5.09422 10.4652 5.15356 10.2963L6.95226 5.39784C7.14399 4.86371 7.46812 4.61719 7.98855 4.61719C8.52724 4.61719 8.84682 4.85457 9.04311 5.39327L10.8509 10.2963C10.9148 10.4743 10.9377 10.5976 10.9377 10.7346C10.9377 11.1135 10.6501 11.3828 10.2483 11.3828C9.86028 11.3828 9.65486 11.2048 9.53159 10.7756L9.18463 9.73477H6.80616L6.45922 10.7619C6.33139 11.2002 6.12595 11.3828 5.76074 11.3828ZM7.10747 8.66652H8.86507L7.99312 5.96848H7.96116L7.10747 8.66652Z" fill="#C6CAD0"/>
+<path opacity="0.3" d="M12 2H4C2.89543 2 2 2.89543 2 4V12C2 13.1046 2.89543 14 4 14H12C13.1046 14 14 13.1046 14 12V4C14 2.89543 13.1046 2 12 2Z" stroke="#C6CAD0" stroke-width="1.2"/>
 </svg>
diff --git a/assets/icons/ai_lm_studio.svg b/assets/icons/ai_lm_studio.svg
index 5cfdeb5578c..eef6bfcdb86 100644
--- a/assets/icons/ai_lm_studio.svg
+++ b/assets/icons/ai_lm_studio.svg
@@ -1,15 +1,15 @@
 <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M12.146 2H4.85398C3.55391 2 2.5 3.05391 2.5 4.35398V11.646C2.5 12.9461 3.55391 14 4.85398 14H12.146C13.4461 14 14.5 12.9461 14.5 11.646V4.35398C14.5 3.05391 13.4461 2 12.146 2Z" stroke="black" stroke-width="1.11504"/>
-<path opacity="0.487119" d="M10.5177 3.60177H6.21681C5.8698 3.60177 5.58849 3.88308 5.58849 4.23009V4.23894C5.58849 4.58595 5.8698 4.86726 6.21681 4.86726H10.5177C10.8647 4.86726 11.146 4.58595 11.146 4.23894V4.23009C11.146 3.88308 10.8647 3.60177 10.5177 3.60177Z" fill="black"/>
-<path opacity="0.845099" d="M8.83628 3.60177H4.53539C4.18838 3.60177 3.90707 3.88308 3.90707 4.23009V4.23894C3.90707 4.58595 4.18838 4.86726 4.53539 4.86726H8.83628C9.18329 4.86726 9.4646 4.58595 9.4646 4.23894V4.23009C9.4646 3.88308 9.18329 3.60177 8.83628 3.60177Z" fill="black"/>
-<path opacity="0.487119" d="M12.7389 5.10619H8.43806C8.09105 5.10619 7.80974 5.3875 7.80974 5.73451V5.74336C7.80974 6.09037 8.09105 6.37168 8.43806 6.37168H12.7389C13.086 6.37168 13.3673 6.09037 13.3673 5.74336V5.73451C13.3673 5.3875 13.086 5.10619 12.7389 5.10619Z" fill="black"/>
-<path opacity="0.845099" d="M11.0575 5.10619H6.75664C6.40963 5.10619 6.12832 5.3875 6.12832 5.73451V5.74336C6.12832 6.09037 6.40963 6.37168 6.75664 6.37168H11.0575C11.4045 6.37168 11.6858 6.09037 11.6858 5.74336V5.73451C11.6858 5.3875 11.4045 5.10619 11.0575 5.10619Z" fill="black"/>
-<path opacity="0.487119" d="M11.5619 6.59292H7.26106C6.91405 6.59292 6.63274 6.87423 6.63274 7.22124V7.23009C6.63274 7.5771 6.91405 7.85841 7.26106 7.85841H11.5619C11.909 7.85841 12.1903 7.5771 12.1903 7.23009V7.22124C12.1903 6.87423 11.909 6.59292 11.5619 6.59292Z" fill="black"/>
-<path opacity="0.845099" d="M9.86284 6.59292H5.56195C5.21494 6.59292 4.93363 6.87423 4.93363 7.22124V7.23009C4.93363 7.5771 5.21494 7.85841 5.56195 7.85841H9.86284C10.2098 7.85841 10.4912 7.5771 10.4912 7.23009V7.22124C10.4912 6.87423 10.2098 6.59292 9.86284 6.59292Z" fill="black"/>
-<path opacity="0.487119" d="M10.1903 8.10619H5.88937C5.54236 8.10619 5.26105 8.3875 5.26105 8.73451V8.74336C5.26105 9.09037 5.54236 9.37168 5.88937 9.37168H10.1903C10.5373 9.37168 10.8186 9.09037 10.8186 8.74336V8.73451C10.8186 8.3875 10.5373 8.10619 10.1903 8.10619Z" fill="black"/>
-<path opacity="0.845099" d="M8.50886 8.10619H4.20797C3.86096 8.10619 3.57965 8.3875 3.57965 8.73451V8.74336C3.57965 9.09037 3.86096 9.37168 4.20797 9.37168H8.50886C8.85587 9.37168 9.13717 9.09037 9.13717 8.74336V8.73451C9.13717 8.3875 8.85587 8.10619 8.50886 8.10619Z" fill="black"/>
-<path opacity="0.487119" d="M10.9513 9.59292H7.37611C7.0291 9.59292 6.74779 9.87423 6.74779 10.2212V10.2301C6.74779 10.5771 7.0291 10.8584 7.37611 10.8584H10.9513C11.2983 10.8584 11.5796 10.5771 11.5796 10.2301V10.2212C11.5796 9.87423 11.2983 9.59292 10.9513 9.59292Z" fill="black"/>
-<path opacity="0.845099" d="M9.23452 9.59292H5.65929C5.31228 9.59292 5.03098 9.87423 5.03098 10.2212V10.2301C5.03098 10.5771 5.31228 10.8584 5.65929 10.8584H9.23452C9.58153 10.8584 9.86283 10.5771 9.86283 10.2301V10.2212C9.86283 9.87423 9.58153 9.59292 9.23452 9.59292Z" fill="black"/>
-<path opacity="0.487119" d="M12.6062 11.0973H9.82744C9.48043 11.0973 9.19912 11.3787 9.19912 11.7257V11.7345C9.19912 12.0815 9.48043 12.3628 9.82744 12.3628H12.6062C12.9532 12.3628 13.2345 12.0815 13.2345 11.7345V11.7257C13.2345 11.3787 12.9532 11.0973 12.6062 11.0973Z" fill="black"/>
-<path opacity="0.845099" d="M10.7389 11.0973H7.96017C7.61316 11.0973 7.33186 11.3787 7.33186 11.7257V11.7345C7.33186 12.0815 7.61316 12.3628 7.96017 12.3628H10.7389C11.0859 12.3628 11.3673 12.0815 11.3673 11.7345V11.7257C11.3673 11.3787 11.0859 11.0973 10.7389 11.0973Z" fill="black"/>
+<path d="M11.646 2H4.35398C3.05391 2 2 3.05391 2 4.35398V11.646C2 12.9461 3.05391 14 4.35398 14H11.646C12.9461 14 14 12.9461 14 11.646V4.35398C14 3.05391 12.9461 2 11.646 2Z" stroke="#C6CAD0" stroke-width="1.11504"/>
+<path opacity="0.487119" d="M10.0177 3.60178H5.71681C5.3698 3.60178 5.08849 3.88309 5.08849 4.2301V4.23895C5.08849 4.58596 5.3698 4.86727 5.71681 4.86727H10.0177C10.3647 4.86727 10.646 4.58596 10.646 4.23895V4.2301C10.646 3.88309 10.3647 3.60178 10.0177 3.60178Z" fill="#C6CAD0"/>
+<path opacity="0.845099" d="M8.33628 3.60178H4.03539C3.68838 3.60178 3.40707 3.88309 3.40707 4.2301V4.23895C3.40707 4.58596 3.68838 4.86727 4.03539 4.86727H8.33628C8.68329 4.86727 8.9646 4.58596 8.9646 4.23895V4.2301C8.9646 3.88309 8.68329 3.60178 8.33628 3.60178Z" fill="#C6CAD0"/>
+<path opacity="0.487119" d="M12.2389 5.1062H7.93806C7.59105 5.1062 7.30974 5.38751 7.30974 5.73452V5.74337C7.30974 6.09038 7.59105 6.37169 7.93806 6.37169H12.2389C12.586 6.37169 12.8673 6.09038 12.8673 5.74337V5.73452C12.8673 5.38751 12.586 5.1062 12.2389 5.1062Z" fill="#C6CAD0"/>
+<path opacity="0.845099" d="M10.5575 5.1062H6.25665C5.90964 5.1062 5.62833 5.38751 5.62833 5.73452V5.74337C5.62833 6.09038 5.90964 6.37169 6.25665 6.37169H10.5575C10.9045 6.37169 11.1858 6.09038 11.1858 5.74337V5.73452C11.1858 5.38751 10.9045 5.1062 10.5575 5.1062Z" fill="#C6CAD0"/>
+<path opacity="0.487119" d="M11.0619 6.59293H6.76106C6.41405 6.59293 6.13274 6.87424 6.13274 7.22125V7.2301C6.13274 7.57711 6.41405 7.85842 6.76106 7.85842H11.0619C11.409 7.85842 11.6903 7.57711 11.6903 7.2301V7.22125C11.6903 6.87424 11.409 6.59293 11.0619 6.59293Z" fill="#C6CAD0"/>
+<path opacity="0.845099" d="M9.36283 6.59293H5.06194C4.71493 6.59293 4.43362 6.87424 4.43362 7.22125V7.2301C4.43362 7.57711 4.71493 7.85842 5.06194 7.85842H9.36283C9.70979 7.85842 9.99119 7.57711 9.99119 7.2301V7.22125C9.99119 6.87424 9.70979 6.59293 9.36283 6.59293Z" fill="#C6CAD0"/>
+<path opacity="0.487119" d="M9.6903 8.1062H5.38937C5.04236 8.1062 4.76105 8.38751 4.76105 8.73452V8.74337C4.76105 9.09038 5.04236 9.37169 5.38937 9.37169H9.6903C10.0373 9.37169 10.3186 9.09038 10.3186 8.74337V8.73452C10.3186 8.38751 10.0373 8.1062 9.6903 8.1062Z" fill="#C6CAD0"/>
+<path opacity="0.845099" d="M8.00886 8.1062H3.70797C3.36096 8.1062 3.07965 8.38751 3.07965 8.73452V8.74337C3.07965 9.09038 3.36096 9.37169 3.70797 9.37169H8.00886C8.35587 9.37169 8.63717 9.09038 8.63717 8.74337V8.73452C8.63717 8.38751 8.35587 8.1062 8.00886 8.1062Z" fill="#C6CAD0"/>
+<path opacity="0.487119" d="M10.4513 9.59293H6.87611C6.5291 9.59293 6.24779 9.87424 6.24779 10.2212V10.2301C6.24779 10.5771 6.5291 10.8584 6.87611 10.8584H10.4513C10.7983 10.8584 11.0796 10.5771 11.0796 10.2301V10.2212C11.0796 9.87424 10.7983 9.59293 10.4513 9.59293Z" fill="#C6CAD0"/>
+<path opacity="0.845099" d="M8.73452 9.59293H5.15929C4.81228 9.59293 4.53098 9.87424 4.53098 10.2212V10.2301C4.53098 10.5771 4.81228 10.8584 5.15929 10.8584H8.73452C9.08153 10.8584 9.36283 10.5771 9.36283 10.2301V10.2212C9.36283 9.87424 9.08153 9.59293 8.73452 9.59293Z" fill="#C6CAD0"/>
+<path opacity="0.487119" d="M12.1062 11.0973H9.32745C8.98044 11.0973 8.69913 11.3787 8.69913 11.7257V11.7345C8.69913 12.0815 8.98044 12.3628 9.32745 12.3628H12.1062C12.4532 12.3628 12.7345 12.0815 12.7345 11.7345V11.7257C12.7345 11.3787 12.4532 11.0973 12.1062 11.0973Z" fill="#C6CAD0"/>
+<path opacity="0.845099" d="M10.2389 11.0973H7.46017C7.11316 11.0973 6.83186 11.3787 6.83186 11.7257V11.7345C6.83186 12.0815 7.11316 12.3628 7.46017 12.3628H10.2389C10.5859 12.3628 10.8673 12.0815 10.8673 11.7345V11.7257C10.8673 11.3787 10.5859 11.0973 10.2389 11.0973Z" fill="#C6CAD0"/>
 </svg>
diff --git a/assets/icons/ai_ollama.svg b/assets/icons/ai_ollama.svg
index 36a88c1ad6d..93071a78730 100644
--- a/assets/icons/ai_ollama.svg
+++ b/assets/icons/ai_ollama.svg
@@ -1,7 +1,7 @@
 <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M5.51933 0.963322C5.38908 0.984547 5.23278 1.05328 5.12258 1.13818C4.78894 1.3939 4.53045 1.93667 4.42125 2.61287C4.38017 2.86859 4.35212 3.22336 4.35212 3.49425C4.35212 3.81365 4.38919 4.22198 4.44229 4.50398C4.45431 4.56666 4.46032 4.62225 4.45531 4.6263C4.4513 4.63033 4.40221 4.67076 4.3471 4.71523C4.15875 4.86684 3.94334 5.10033 3.79505 5.31361C3.51052 5.72094 3.32617 6.18387 3.24902 6.68519C3.21896 6.8833 3.21095 7.28355 3.23499 7.48166C3.28809 7.93852 3.42435 8.32463 3.65779 8.6784L3.73394 8.79261L3.7119 8.83001C3.5556 9.09483 3.42234 9.4779 3.36023 9.84581C3.31114 10.1369 3.30513 10.2147 3.30513 10.6049C3.30513 10.9981 3.31013 11.0759 3.35622 11.3478C3.41133 11.6733 3.52354 12.018 3.64878 12.2474C3.68986 12.3221 3.79005 12.4778 3.80207 12.4859C3.80608 12.4879 3.79406 12.5253 3.77502 12.5688C3.63074 12.8871 3.50751 13.3107 3.45641 13.6675C3.42034 13.9121 3.41534 13.9909 3.41534 14.2487C3.41534 14.5771 3.43337 14.7368 3.5015 14.9986L3.51152 15.037H3.94034H4.37015L4.3421 14.9834C4.16877 14.66 4.15274 14.0596 4.30202 13.4602C4.37015 13.1833 4.4473 12.9802 4.59157 12.7001L4.67774 12.5304V12.4263C4.67774 12.3292 4.67574 12.3181 4.64468 12.2544C4.62063 12.2059 4.58857 12.1645 4.53146 12.1079C4.43428 12.0129 4.36414 11.9128 4.30803 11.7895C4.06157 11.2497 4.01348 10.4482 4.1868 9.76495C4.25894 9.47992 4.37817 9.22623 4.5034 9.08775C4.58857 8.99273 4.63265 8.88662 4.63265 8.77644C4.63265 8.66222 4.59258 8.56823 4.5024 8.47019C4.24391 8.19122 4.0846 7.8516 4.0275 7.4564C3.94635 6.89341 4.09362 6.27987 4.42826 5.79372C4.75588 5.31662 5.21575 5.01037 5.72975 4.9285C5.84495 4.9093 6.06037 4.91233 6.18059 4.93458C6.31185 4.95782 6.394 4.95073 6.47817 4.9103C6.58236 4.86079 6.63446 4.79913 6.69558 4.65762C6.74968 4.53129 6.79176 4.46254 6.90497 4.32003C7.04124 4.14922 7.17248 4.03298 7.38288 3.89248C7.62335 3.73379 7.89686 3.61857 8.16938 3.56297C8.26856 3.54276 8.31465 3.53973 8.50001 3.53973C8.68537 3.53973 8.73146 3.54276 8.83063 3.56297C9.23039 3.64486 9.62715 3.85307 9.94376 4.1482C10.0119 4.21187 10.1752 4.41605 10.2273 4.50096C10.2473 4.5343 10.2824 4.60507 10.3044 4.65762C10.3655 4.79913 10.4176 4.86079 10.5218 4.9103C10.603 4.94973 10.6881 4.95782 10.8144 4.93659C11.0138 4.90223 11.1671 4.90526 11.3625 4.94569C12.0277 5.08112 12.6069 5.63401 12.8633 6.3749C13.0867 7.0248 13.0236 7.70504 12.691 8.22456C12.6349 8.31251 12.5788 8.38326 12.4976 8.47019C12.3223 8.65919 12.3223 8.89369 12.4966 9.08775C12.7832 9.40412 12.9625 10.1824 12.9083 10.8687C12.8723 11.3215 12.7571 11.7269 12.5988 11.9563C12.5708 11.9967 12.5127 12.0655 12.4686 12.1079C12.4114 12.1645 12.3794 12.2059 12.3553 12.2544C12.3243 12.3181 12.3223 12.3292 12.3223 12.4263V12.5304L12.4085 12.7001C12.5527 12.9802 12.6298 13.1833 12.698 13.4602C12.8453 14.0515 12.8322 14.6399 12.6639 14.9744C12.6499 15.0027 12.6378 15.029 12.6378 15.032C12.6378 15.0351 12.8293 15.037 13.0636 15.037H13.4885L13.4995 14.9936C13.5056 14.9704 13.5155 14.935 13.5205 14.9147C13.5316 14.8703 13.5536 14.7389 13.5716 14.6125C13.5886 14.4851 13.5886 14.0162 13.5716 13.8747C13.5075 13.3612 13.4003 12.9539 13.225 12.5688C13.2059 12.5253 13.1939 12.4879 13.1979 12.4859C13.2029 12.4829 13.231 12.4425 13.261 12.3969C13.4795 12.0634 13.6138 11.644 13.6819 11.09C13.6999 10.9374 13.6999 10.2815 13.6819 10.1349C13.6338 9.75687 13.5756 9.50013 13.4795 9.24037C13.4394 9.13223 13.3332 8.9038 13.2881 8.83001L13.266 8.79261L13.3422 8.6784C13.5756 8.32463 13.7119 7.93852 13.765 7.48166C13.7891 7.28355 13.7811 6.8833 13.751 6.68519C13.6729 6.18284 13.4895 5.72194 13.205 5.31361C13.0567 5.10033 12.8413 4.86684 12.6529 4.71523C12.5978 4.67076 12.5487 4.63033 12.5447 4.6263C12.5397 4.62225 12.5457 4.56666 12.5577 4.50398C12.679 3.86619 12.675 3.07074 12.5477 2.44913C12.4375 1.90737 12.2372 1.47679 11.9787 1.22814C11.7723 1.03003 11.5618 0.945128 11.3093 0.9613C10.7303 0.995666 10.2634 1.66781 10.079 2.72708C10.049 2.8979 10.0229 3.09803 10.0229 3.15261C10.0229 3.17384 10.0189 3.19101 10.0139 3.19101C10.0089 3.19101 9.96981 3.1708 9.92772 3.14554C9.48088 2.87869 8.98392 2.73619 8.50001 2.73619C8.01609 2.73619 7.51914 2.87869 7.07229 3.14554C7.0302 3.1708 6.99114 3.19101 6.98612 3.19101C6.98113 3.19101 6.9771 3.17384 6.9771 3.15261C6.9771 3.096 6.95006 2.88982 6.92101 2.72708C6.75368 1.77596 6.36995 1.14627 5.85999 0.987579C5.78986 0.966354 5.59047 0.952204 5.51933 0.963322ZM5.68967 1.78607C5.83394 1.9013 5.99424 2.23081 6.08641 2.59973C6.10345 2.66644 6.12148 2.74326 6.12649 2.77155C6.1305 2.79886 6.14151 2.8605 6.15054 2.908C6.18962 3.12229 6.20764 3.35375 6.20965 3.63575L6.21065 3.91371L6.14151 4.0168L6.07239 4.12091H5.91108C5.72273 4.12091 5.53536 4.14517 5.35602 4.19369C5.2919 4.20986 5.22978 4.22604 5.21776 4.22907C5.19873 4.23311 5.19572 4.22704 5.1847 4.14416C5.12559 3.69437 5.12859 3.19607 5.19372 2.78166C5.26585 2.31975 5.43418 1.9013 5.59849 1.77799C5.63756 1.74867 5.64458 1.74969 5.68967 1.78607ZM11.4025 1.779C11.5017 1.85278 11.6109 2.04887 11.6921 2.29953C11.8554 2.80087 11.9015 3.48919 11.8154 4.14416C11.8043 4.22704 11.8013 4.23311 11.7822 4.22907C11.7702 4.22604 11.7081 4.20986 11.644 4.19369C11.4646 4.14517 11.2772 4.12091 11.0889 4.12091H10.9276L10.8585 4.0168L10.7894 3.91371L10.7904 3.63575C10.7923 3.24357 10.8284 2.93732 10.9146 2.5967C11.0058 2.23081 11.1671 1.9013 11.3104 1.78607C11.3554 1.74969 11.3625 1.74867 11.4025 1.779Z" fill="black"/>
-<path d="M8.37317 6.82775C8.19555 6.84978 8.14728 6.85816 8.06215 6.88019C7.92382 6.91688 7.73884 6.99866 7.61035 7.07938C7.16347 7.35931 6.85573 7.82587 6.76159 8.36582C6.74277 8.47276 6.74031 8.5084 6.74031 8.68874C6.74031 8.86697 6.74277 8.90576 6.76078 9.00745C6.88601 9.71306 7.39345 10.2342 8.04987 10.3296C8.19229 10.3494 8.80778 10.3494 8.95019 10.3296C9.47729 10.253 9.93072 9.8871 10.1345 9.37336C10.1885 9.23603 10.2147 9.1469 10.2393 9.00745C10.2573 8.90576 10.2597 8.86697 10.2597 8.68874C10.2597 8.5084 10.2573 8.47276 10.2384 8.36582C10.1018 7.58159 9.50757 6.96406 8.77913 6.84663C8.68418 6.83196 8.43538 6.81937 8.37317 6.82775ZM8.67927 7.39811C8.92237 7.43166 9.16709 7.54279 9.36352 7.71054C9.4691 7.80071 9.61807 7.98943 9.6819 8.11315C9.76048 8.2662 9.80549 8.42243 9.82595 8.6122C9.83495 8.69922 9.83006 8.76527 9.80549 8.90576C9.76702 9.11545 9.64752 9.33457 9.48629 9.48764C9.41098 9.55788 9.25466 9.6596 9.15891 9.69943C8.9772 9.77386 8.85852 9.78749 8.43455 9.7833C8.15792 9.78016 8.1088 9.777 8.02941 9.75814C7.7585 9.69314 7.54406 9.55474 7.38855 9.34401C7.2625 9.17415 7.20521 9.019 7.17411 8.76842C7.1602 8.65204 7.18638 8.45913 7.23959 8.29661C7.30425 8.09846 7.47121 7.85209 7.63654 7.71054C7.82806 7.54699 8.08015 7.43062 8.31178 7.39917C8.40099 7.38658 8.59006 7.38658 8.67927 7.39811Z" fill="black"/>
-<path d="M8.05397 8.02145C7.96179 8.0691 7.8975 8.19001 7.91692 8.27951C7.93874 8.37601 8.02729 8.47367 8.16555 8.55388C8.23955 8.5969 8.2444 8.6027 8.24805 8.64571C8.25046 8.67129 8.24076 8.74454 8.22742 8.80964C8.21287 8.87357 8.20194 8.94101 8.20194 8.95961C8.20317 9.0096 8.25168 9.09097 8.30261 9.13049C8.3475 9.16537 8.356 9.16652 8.48213 9.17001C8.59736 9.1735 8.62162 9.17116 8.66771 9.15025C8.78658 9.09444 8.81689 8.99215 8.77323 8.79568C8.73684 8.63177 8.74412 8.60619 8.8351 8.5562C8.9309 8.50272 9.0328 8.40857 9.06311 8.34462C9.12135 8.22257 9.06796 8.08422 8.93939 8.02028C8.90787 8.00516 8.86905 7.9982 8.81205 7.9982C8.7235 7.9982 8.6665 8.01796 8.56219 8.08189L8.50275 8.11794L8.46515 8.09585C8.31112 8.00865 8.28323 7.9982 8.18981 7.99935C8.12311 7.99935 8.08672 8.00516 8.05397 8.02145Z" fill="black"/>
-<path d="M6.02787 6.84439C5.83235 6.90397 5.68655 7.04226 5.61144 7.23906C5.57499 7.33268 5.55732 7.48054 5.57278 7.56032C5.60923 7.75073 5.77159 7.92412 5.95608 7.972C6.18803 8.0305 6.36144 7.9922 6.51498 7.84541C6.60445 7.76137 6.65307 7.68797 6.70166 7.56882C6.73699 7.4848 6.73921 7.46991 6.73921 7.35076L6.74031 7.2231L6.69393 7.13163C6.61991 6.98695 6.48626 6.8795 6.33163 6.84015C6.24436 6.81886 6.10408 6.81994 6.02787 6.84439Z" fill="black"/>
-<path d="M10.6638 6.84103C10.5126 6.88038 10.3778 6.9889 10.3061 7.13148L10.2597 7.22298L10.2608 7.35065C10.2608 7.46982 10.263 7.48471 10.2984 7.56875C10.347 7.68791 10.3955 7.76133 10.4849 7.84538C10.6384 7.99219 10.8117 8.0305 11.0436 7.972C11.1771 7.93794 11.3107 7.82941 11.3748 7.7028C11.43 7.59535 11.4432 7.51768 11.4255 7.39532C11.3847 7.11551 11.2146 6.9123 10.9619 6.84103C10.8878 6.81974 10.7444 6.81974 10.6638 6.84103Z" fill="black"/>
+<path d="M5.01932 0.965138C4.88906 0.986363 4.73277 1.0551 4.62257 1.14C4.28893 1.39572 4.03043 1.93849 3.92123 2.61469C3.88015 2.87041 3.8521 3.22518 3.8521 3.49607C3.8521 3.81547 3.88917 4.2238 3.94227 4.5058C3.95429 4.56848 3.9603 4.62407 3.95529 4.62812C3.95128 4.63215 3.90219 4.67258 3.84708 4.71705C3.65873 4.86866 3.44332 5.10215 3.29503 5.31543C3.0105 5.72276 2.82616 6.18569 2.74901 6.68701C2.71895 6.88512 2.71093 7.28537 2.73497 7.48348C2.78807 7.94034 2.92433 8.32645 3.15777 8.68022L3.23392 8.79443L3.21189 8.83183C3.05559 9.09665 2.92232 9.47972 2.86021 9.84763C2.81112 10.1387 2.80512 10.2165 2.80512 10.6067C2.80512 10.9999 2.81012 11.0777 2.85621 11.3496C2.91132 11.6751 3.02353 12.0198 3.14877 12.2492C3.18985 12.3239 3.29003 12.4796 3.30205 12.4877C3.30606 12.4897 3.29404 12.5271 3.275 12.5706C3.13072 12.8889 3.00749 13.3125 2.95639 13.6693C2.92032 13.9139 2.91532 13.9927 2.91532 14.2505C2.91532 14.5789 2.93335 14.7386 3.00148 15.0004L3.0115 15.0388H3.44033H3.87014L3.84209 14.9852C3.66876 14.6618 3.65273 14.0614 3.80201 13.462C3.87014 13.1851 3.94728 12.982 4.09155 12.7019L4.17773 12.5322V12.4281C4.17773 12.331 4.17573 12.3199 4.14467 12.2562C4.12062 12.2077 4.08855 12.1663 4.03144 12.1097C3.93426 12.0147 3.86413 11.9146 3.80802 11.7913C3.56156 11.2515 3.51347 10.45 3.68679 9.76677C3.75893 9.48174 3.87815 9.22805 4.00338 9.08957C4.08855 8.99455 4.13263 8.88844 4.13263 8.77826C4.13263 8.66404 4.09256 8.57005 4.00238 8.47201C3.74389 8.19304 3.58459 7.85342 3.52749 7.45822C3.44634 6.89523 3.5936 6.28169 3.92824 5.79554C4.25586 5.31844 4.71574 5.01219 5.22974 4.93032C5.34494 4.91112 5.56036 4.91415 5.68058 4.9364C5.81184 4.95964 5.89398 4.95255 5.97815 4.91212C6.08234 4.86261 6.13444 4.80095 6.19556 4.65944C6.24966 4.53311 6.29175 4.46436 6.40496 4.32185C6.54123 4.15104 6.67247 4.0348 6.88287 3.8943C7.12334 3.73561 7.39685 3.62039 7.66937 3.56479C7.76855 3.54458 7.81463 3.54155 7.99999 3.54155C8.18535 3.54155 8.23145 3.54458 8.33062 3.56479C8.73038 3.64668 9.12714 3.85489 9.44375 4.15002C9.51189 4.21369 9.67518 4.41787 9.72728 4.50278C9.74728 4.53612 9.78239 4.60689 9.80439 4.65944C9.86549 4.80095 9.91759 4.86261 10.0218 4.91212C10.103 4.95155 10.1881 4.95964 10.3144 4.93841C10.5138 4.90405 10.6671 4.90708 10.8625 4.94751C11.5277 5.08294 12.1069 5.63583 12.3633 6.37672C12.5867 7.02662 12.5236 7.70686 12.191 8.22638C12.1349 8.31433 12.0788 8.38508 11.9976 8.47201C11.8223 8.66101 11.8223 8.89551 11.9966 9.08957C12.2832 9.40594 12.4625 10.1842 12.4083 10.8705C12.3723 11.3233 12.2571 11.7287 12.0988 11.9581C12.0708 11.9985 12.0127 12.0673 11.9686 12.1097C11.9114 12.1663 11.8794 12.2077 11.8553 12.2562C11.8243 12.3199 11.8223 12.331 11.8223 12.4281V12.5322L11.9085 12.7019C12.0527 12.982 12.1298 13.1851 12.198 13.462C12.3453 14.0533 12.3322 14.6417 12.1639 14.9762C12.1499 15.0045 12.1378 15.0308 12.1378 15.0338C12.1378 15.0369 12.3293 15.0388 12.5636 15.0388H12.9885L12.9995 14.9954C13.0056 14.9722 13.0155 14.9368 13.0205 14.9165C13.0316 14.8721 13.0536 14.7407 13.0716 14.6143C13.0886 14.4869 13.0886 14.018 13.0716 13.8765C13.0075 13.363 12.9003 12.9557 12.725 12.5706C12.7059 12.5271 12.6939 12.4897 12.6979 12.4877C12.7029 12.4847 12.731 12.4443 12.761 12.3987C12.9795 12.0652 13.1138 11.6458 13.1819 11.0918C13.1999 10.9392 13.1999 10.2833 13.1819 10.1367C13.1338 9.75869 13.0756 9.50195 12.9795 9.24219C12.9394 9.13405 12.8332 8.90562 12.7881 8.83183L12.766 8.79443L12.8422 8.68022C13.0756 8.32645 13.2119 7.94034 13.265 7.48348C13.2891 7.28537 13.2811 6.88512 13.251 6.68701C13.1729 6.18466 12.9895 5.72376 12.705 5.31543C12.5567 5.10215 12.3413 4.86866 12.1529 4.71705C12.0978 4.67258 12.0487 4.63215 12.0447 4.62812C12.0397 4.62407 12.0457 4.56848 12.0577 4.5058C12.179 3.86801 12.175 3.07256 12.0477 2.45095C11.9375 1.90919 11.7372 1.47861 11.4787 1.22996C11.2723 1.03185 11.0618 0.946944 10.8093 0.963116C10.2303 0.997482 9.76339 1.66963 9.57899 2.7289C9.54899 2.89972 9.52288 3.09985 9.52288 3.15443C9.52288 3.17566 9.51889 3.19283 9.51389 3.19283C9.50889 3.19283 9.4698 3.17262 9.42771 3.14736C8.98087 2.88051 8.4839 2.73801 7.99999 2.73801C7.51607 2.73801 7.01912 2.88051 6.57227 3.14736C6.53018 3.17262 6.49113 3.19283 6.48611 3.19283C6.48112 3.19283 6.47708 3.17566 6.47708 3.15443C6.47708 3.09782 6.45004 2.89164 6.42099 2.7289C6.25367 1.77778 5.86994 1.14809 5.35998 0.989395C5.28985 0.96817 5.09046 0.95402 5.01932 0.965138ZM5.18966 1.78789C5.33393 1.90312 5.49423 2.23263 5.5864 2.60155C5.60344 2.66826 5.62147 2.74508 5.62648 2.77337C5.63049 2.80068 5.64149 2.86232 5.65052 2.90982C5.6896 3.12411 5.70763 3.35557 5.70964 3.63757L5.71063 3.91553L5.64149 4.01862L5.57238 4.12273H5.41106C5.22271 4.12273 5.03534 4.14699 4.856 4.19551C4.79188 4.21168 4.72977 4.22786 4.71775 4.23089C4.69872 4.23493 4.6957 4.22886 4.68468 4.14598C4.62557 3.69619 4.62857 3.19789 4.6937 2.78348C4.76583 2.32157 4.93417 1.90312 5.09848 1.77981C5.13755 1.75049 5.14457 1.75151 5.18966 1.78789ZM10.9025 1.78082C11.0017 1.8546 11.1109 2.05069 11.1921 2.30135C11.3554 2.80269 11.4015 3.49101 11.3154 4.14598C11.3043 4.22886 11.3013 4.23493 11.2822 4.23089C11.2702 4.22786 11.2081 4.21168 11.144 4.19551C10.9646 4.14699 10.7772 4.12273 10.5889 4.12273H10.4276L10.3585 4.01862L10.2894 3.91553L10.2904 3.63757C10.2923 3.24539 10.3284 2.93914 10.4146 2.59852C10.5058 2.23263 10.6671 1.90312 10.8104 1.78789C10.8554 1.75151 10.8625 1.75049 10.9025 1.78082Z" fill="#C6CAD0"/>
+<path d="M7.87316 6.82959C7.69554 6.85162 7.64727 6.86 7.56214 6.88203C7.42381 6.91872 7.23883 7.0005 7.11034 7.08122C6.66346 7.36115 6.35572 7.82771 6.26158 8.36766C6.24276 8.4746 6.2403 8.51024 6.2403 8.69058C6.2403 8.86881 6.24276 8.9076 6.26077 9.00929C6.386 9.7149 6.89343 10.236 7.54985 10.3314C7.69227 10.3512 8.30776 10.3512 8.45017 10.3314C8.97727 10.2548 9.4307 9.88894 9.63448 9.3752C9.68848 9.23787 9.71468 9.14874 9.73928 9.00929C9.75728 8.9076 9.75969 8.86881 9.75969 8.69058C9.75969 8.51024 9.75729 8.4746 9.73839 8.36766C9.60179 7.58343 9.00756 6.9659 8.27912 6.84847C8.18417 6.8338 7.93537 6.82121 7.87316 6.82959ZM8.17926 7.39995C8.42236 7.4335 8.66707 7.54463 8.8635 7.71238C8.96908 7.80255 9.11806 7.99127 9.18189 8.11499C9.26047 8.26804 9.30547 8.42427 9.32593 8.61404C9.33493 8.70106 9.33004 8.76711 9.30547 8.9076C9.267 9.11729 9.14751 9.33641 8.98628 9.48948C8.91097 9.55972 8.75465 9.66144 8.6589 9.70127C8.47719 9.7757 8.35851 9.78933 7.93454 9.78514C7.65791 9.782 7.60879 9.77884 7.5294 9.75998C7.25849 9.69498 7.04405 9.55658 6.88854 9.34585C6.76249 9.17599 6.7052 9.02084 6.6741 8.77026C6.66019 8.65388 6.68637 8.46097 6.73958 8.29845C6.80424 8.1003 6.9712 7.85393 7.13653 7.71238C7.32805 7.54883 7.58014 7.43246 7.81177 7.40101C7.90098 7.38842 8.09005 7.38842 8.17926 7.39995Z" fill="#C6CAD0"/>
+<path d="M7.55396 8.02325C7.46178 8.0709 7.39749 8.19181 7.41691 8.28131C7.43873 8.37781 7.52728 8.47547 7.66554 8.55568C7.73954 8.5987 7.74439 8.6045 7.74804 8.64751C7.75045 8.67309 7.74075 8.74634 7.72741 8.81144C7.71286 8.87537 7.70193 8.94281 7.70193 8.96141C7.70316 9.0114 7.75167 9.09277 7.8026 9.13229C7.84749 9.16717 7.85599 9.16832 7.98212 9.17181C8.09735 9.1753 8.12161 9.17296 8.1677 9.15205C8.28657 9.09624 8.31688 8.99395 8.27322 8.79748C8.23683 8.63357 8.24411 8.60799 8.33509 8.558C8.43089 8.50452 8.53279 8.41037 8.5631 8.34642C8.62134 8.22437 8.56795 8.08602 8.43938 8.02208C8.40786 8.00696 8.36904 8 8.31204 8C8.22349 8 8.16649 8.01976 8.06218 8.08369L8.00274 8.11974L7.96514 8.09765C7.81111 8.01045 7.78322 8 7.6898 8.00115C7.6231 8.00115 7.58671 8.00696 7.55396 8.02325Z" fill="#C6CAD0"/>
+<path d="M5.52785 6.84623C5.33233 6.90581 5.18653 7.0441 5.11142 7.2409C5.07497 7.33452 5.0573 7.48238 5.07276 7.56216C5.10921 7.75257 5.27157 7.92597 5.45606 7.97385C5.68801 8.03235 5.86142 7.99404 6.01496 7.84725C6.10443 7.76321 6.15305 7.68981 6.20164 7.57066C6.23697 7.48664 6.23919 7.47175 6.23919 7.3526L6.24029 7.22495L6.19391 7.13347C6.11989 6.98879 5.98624 6.88134 5.83161 6.84199C5.74434 6.8207 5.60406 6.82178 5.52785 6.84623Z" fill="#C6CAD0"/>
+<path d="M10.1638 6.84287C10.0126 6.88222 9.87779 6.99074 9.80609 7.13332L9.75969 7.22482L9.76079 7.35249C9.76079 7.47166 9.76299 7.48655 9.79839 7.57059C9.84699 7.68975 9.89549 7.76317 9.98489 7.84722C10.1384 7.99403 10.3117 8.03234 10.5436 7.97384C10.6771 7.93978 10.8107 7.83125 10.8748 7.70464C10.93 7.59719 10.9432 7.51952 10.9255 7.39716C10.8847 7.11735 10.7146 6.91414 10.4619 6.84287C10.3878 6.82158 10.2444 6.82158 10.1638 6.84287Z" fill="#C6CAD0"/>
 </svg>
diff --git a/assets/icons/ai_open_ai.svg b/assets/icons/ai_open_ai.svg
index e45ac315a01..857a03091bd 100644
--- a/assets/icons/ai_open_ai.svg
+++ b/assets/icons/ai_open_ai.svg
@@ -1,3 +1,3 @@
 <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M14.5768 6.73011C14.8987 5.77678 14.7879 4.73245 14.2731 3.86531C13.4989 2.53528 11.9427 1.85102 10.4227 2.17303C9.74656 1.42139 8.7751 0.993944 7.75664 1.00006C6.20301 0.996569 4.82452 1.98358 4.34655 3.44224C3.34849 3.64393 2.48699 4.26038 1.98286 5.13408C1.20294 6.46061 1.38074 8.13277 2.4227 9.27029C2.1008 10.2236 2.21164 11.268 2.72642 12.1351C3.50057 13.4651 5.05686 14.1494 6.57679 13.8274C7.25251 14.579 8.22441 15.0064 9.24287 14.9999C10.7974 15.0038 12.1763 14.0159 12.6543 12.556C13.6524 12.3543 14.5139 11.7379 15.018 10.8641C15.797 9.5376 15.6188 7.86676 14.5773 6.72924L14.5768 6.73011ZM9.24376 14.0851C8.62169 14.0859 8.01912 13.8711 7.5416 13.4778C7.56332 13.4664 7.60101 13.4459 7.6254 13.431L10.4507 11.821C10.5952 11.7401 10.6839 11.5882 10.683 11.4242V7.49401L11.877 8.17433C11.8899 8.18045 11.8983 8.1927 11.9001 8.2067V11.4614C11.8983 12.9086 10.7105 14.082 9.24376 14.0851ZM3.53116 11.6775C3.21946 11.1464 3.10729 10.5237 3.21414 9.91955C3.23498 9.9318 3.27178 9.95411 3.29794 9.96898L6.1232 11.5791C6.26642 11.6617 6.44377 11.6617 6.58743 11.5791L10.0365 9.61373V10.9744C10.0374 10.9884 10.0308 11.002 10.0197 11.0107L7.16383 12.6378C5.89175 13.3606 4.26674 12.9309 3.53116 11.6775ZM2.7876 5.59215C3.09797 5.06014 3.58792 4.65326 4.17141 4.44195C4.17141 4.46601 4.17008 4.50845 4.17008 4.5382V7.75869C4.1692 7.92232 4.25787 8.07414 4.40198 8.15508L7.85108 10.1199L6.65704 10.8002C6.64507 10.8081 6.62999 10.8094 6.61669 10.8037L3.76039 9.17535C2.49098 8.44995 2.05601 6.84692 2.7876 5.59215ZM12.598 7.84488L9.14887 5.8796L10.3429 5.19971C10.3549 5.19183 10.37 5.19052 10.3833 5.19621L13.2396 6.8233C14.5112 7.54826 14.947 9.15347 14.2124 10.4082C13.9015 10.9394 13.412 11.3463 12.829 11.5581V8.24127C12.8303 8.07764 12.7417 7.92626 12.598 7.84488ZM13.7863 6.07998C13.7654 6.06729 13.7286 6.04541 13.7025 6.03054L10.8772 4.42051C10.734 4.33782 10.5566 4.33782 10.413 4.42051L6.96386 6.3858V5.02514C6.96298 5.01114 6.96963 4.99758 6.98071 4.98883L9.83657 3.36305C11.1086 2.63898 12.735 3.06992 13.4683 4.32557C13.7783 4.85583 13.8914 5.47665 13.7863 6.07998ZM6.31475 8.50509L5.12026 7.82476C5.1074 7.81863 5.09898 7.80638 5.09721 7.79238V4.53776C5.09809 3.08873 6.28947 1.91446 7.75797 1.91533C8.37916 1.91533 8.98039 2.13059 9.45792 2.52259C9.43619 2.53397 9.39894 2.55453 9.37412 2.56941L6.54885 4.17944C6.40431 4.26038 6.31563 4.41176 6.31652 4.57582L6.31475 8.50509ZM6.96342 7.12518L8.49976 6.24973L10.0361 7.12475V8.87521L8.49976 9.75023L6.96342 8.87521V7.12518Z" fill="black"/>
+<path d="M14.0768 6.73011C14.3987 5.77678 14.2879 4.73245 13.7731 3.86531C12.9989 2.53528 11.4427 1.85102 9.9227 2.17303C9.24656 1.42139 8.2751 0.993949 7.25664 1.00006C5.70301 0.996574 4.32452 1.98358 3.84655 3.44224C2.84849 3.64393 1.98699 4.26038 1.48286 5.13408C0.702939 6.46061 0.880738 8.13278 1.9227 9.2703C1.6008 10.2236 1.71164 11.268 2.22642 12.1351C3.00057 13.4651 4.55686 14.1494 6.07679 13.8274C6.75251 14.579 7.72441 15.0064 8.74287 14.9999C10.2974 15.0038 11.6763 14.0159 12.1543 12.556C13.1524 12.3543 14.0139 11.7379 14.518 10.8641C15.297 9.53761 15.1188 7.86676 14.0773 6.72924L14.0768 6.73011ZM8.74376 14.0851C8.12169 14.0859 7.51912 13.8711 7.0416 13.4778C7.06332 13.4664 7.10101 13.4459 7.1254 13.431L9.9507 11.821C10.0952 11.7401 10.1839 11.5882 10.183 11.4242V7.49401L11.377 8.17433C11.3899 8.18045 11.3983 8.19271 11.4001 8.20671V11.4614C11.3983 12.9086 10.2105 14.082 8.74376 14.0851ZM3.03116 11.6775C2.71946 11.1464 2.60729 10.5237 2.71414 9.91955C2.73498 9.9318 2.77178 9.95411 2.79794 9.96898L5.6232 11.5791C5.76642 11.6617 5.94377 11.6617 6.08743 11.5791L9.5365 9.61374V10.9744C9.5374 10.9884 9.5308 11.002 9.5197 11.0107L6.66383 12.6378C5.39175 13.3606 3.76674 12.9309 3.03116 11.6775ZM2.2876 5.59215C2.59797 5.06014 3.08792 4.65326 3.67141 4.44195C3.67141 4.46601 3.67008 4.50845 3.67008 4.5382V7.75869C3.6692 7.92232 3.75787 8.07414 3.90198 8.15508L7.35108 10.1199L6.15704 10.8002C6.14507 10.8081 6.12999 10.8094 6.11669 10.8037L3.26039 9.17535C1.99098 8.44995 1.55601 6.84693 2.2876 5.59215ZM12.098 7.84488L8.64887 5.8796L9.8429 5.19971C9.8549 5.19183 9.87 5.19052 9.8833 5.19621L12.7396 6.8233C14.0112 7.54826 14.447 9.15348 13.7124 10.4082C13.4015 10.9394 12.912 11.3463 12.329 11.5581V8.24127C12.3303 8.07764 12.2417 7.92626 12.098 7.84488ZM13.2863 6.07998C13.2654 6.06729 13.2286 6.04541 13.2025 6.03054L10.3772 4.42051C10.234 4.33782 10.0566 4.33782 9.913 4.42051L6.46386 6.3858V5.02514C6.46298 5.01114 6.46963 4.99758 6.48071 4.98883L9.33657 3.36305C10.6086 2.63898 12.235 3.06992 12.9683 4.32557C13.2783 4.85583 13.3914 5.47665 13.2863 6.07998ZM5.81475 8.50509L4.62026 7.82476C4.6074 7.81863 4.59898 7.80638 4.59721 7.79238V4.53776C4.59809 3.08873 5.78947 1.91446 7.25797 1.91533C7.87916 1.91533 8.48039 2.13059 8.95792 2.52259C8.93619 2.53397 8.89894 2.55453 8.87412 2.56941L6.04885 4.17944C5.90431 4.26038 5.81563 4.41176 5.81652 4.57582L5.81475 8.50509ZM6.46342 7.12518L7.99976 6.24973L9.5361 7.12475V8.87521L7.99976 9.75023L6.46342 8.87521V7.12518Z" fill="#C6CAD0"/>
 </svg>
diff --git a/assets/icons/ai_x_ai.svg b/assets/icons/ai_x_ai.svg
index d3400fbe9cd..dabee6f54df 100644
--- a/assets/icons/ai_x_ai.svg
+++ b/assets/icons/ai_x_ai.svg
@@ -1,3 +1,3 @@
 <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M12.8451 5.50949L13.1109 15H15.2342L15.5 2.05527L12.8451 5.50949ZM15.499 1H12.2574L7.17206 7.61904L8.79335 9.72761L15.499 1ZM1.5 14.999H4.73963L6.36092 12.8905L4.73963 10.7809L1.5 14.999ZM1.5 5.50851L8.79335 14.999H12.034L4.74061 5.50949L1.5 5.50851Z" fill="black"/>
+<path d="M12.3451 5.50949L12.6109 15H14.7342L15 2.05527L12.3451 5.50949ZM14.999 1H11.7574L6.67206 7.61904L8.29335 9.72761L14.999 1ZM1 14.999H4.23963L5.86092 12.8905L4.23963 10.7809L1 14.999ZM1 5.50851L8.29335 14.999H11.534L4.24061 5.50949L1 5.50851Z" fill="#C6CAD0"/>
 </svg>
diff --git a/assets/icons/ai_zed.svg b/assets/icons/ai_zed.svg
index 6d78efacd5f..5ba2dbed183 100644
--- a/assets/icons/ai_zed.svg
+++ b/assets/icons/ai_zed.svg
@@ -1,3 +1,3 @@
 <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M3.625 2.75C3.4179 2.75 3.25 2.9179 3.25 3.125V11.375H2.5V3.125C2.5 2.50368 3.00368 2 3.625 2H13.6723C14.1735 2 14.4244 2.6059 14.0701 2.96025L7.88189 9.14843H9.625V8.375H10.375V9.33593C10.375 9.6466 10.1232 9.8984 9.8125 9.8984H7.13189L5.84282 11.1875H11.6875V6.5H12.4375V11.1875C12.4375 11.6017 12.1017 11.9375 11.6875 11.9375H5.09282L3.78032 13.25H13.375C13.5821 13.25 13.75 13.0821 13.75 12.875V4.625H14.5V12.875C14.5 13.4963 13.9963 14 13.375 14H3.32767C2.82653 14 2.57557 13.3941 2.92992 13.0397L9.09468 6.875H7.375V7.625H6.625V6.6875C6.625 6.37684 6.87684 6.125 7.1875 6.125H9.84468L11.1571 4.8125H5.3125V9.5H4.5625V4.8125C4.5625 4.39829 4.89829 4.0625 5.3125 4.0625H11.9071L13.2197 2.75H3.625Z" fill="black"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M3.125 2.75C2.9179 2.75 2.75 2.9179 2.75 3.125V11.375H2V3.125C2 2.50368 2.50368 2 3.125 2H13.1723C13.6735 2 13.9244 2.6059 13.5701 2.96025L7.38189 9.14843H9.125V8.375H9.875V9.33593C9.875 9.6466 9.6232 9.8984 9.3125 9.8984H6.63189L5.34282 11.1875H11.1875V6.5H11.9375V11.1875C11.9375 11.6017 11.6017 11.9375 11.1875 11.9375H4.59282L3.28032 13.25H12.875C13.0821 13.25 13.25 13.0821 13.25 12.875V4.625H14V12.875C14 13.4963 13.4963 14 12.875 14H2.82767C2.32653 14 2.07557 13.3941 2.42992 13.0397L8.59468 6.875H6.875V7.625H6.125V6.6875C6.125 6.37684 6.37684 6.125 6.6875 6.125H9.34468L10.6571 4.8125H4.8125V9.5H4.0625V4.8125C4.0625 4.39829 4.39829 4.0625 4.8125 4.0625H11.4071L12.7197 2.75H3.125Z" fill="#C6CAD0"/>
 </svg>
diff --git a/assets/icons/editor_atom.svg b/assets/icons/editor_atom.svg
index cc5fa83843f..ca9c3380c43 100644
--- a/assets/icons/editor_atom.svg
+++ b/assets/icons/editor_atom.svg
@@ -1,3 +1,3 @@
 <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M6.18462 2.1437C6.38492 2.13508 6.58308 2.16739 6.77046 2.23631C7.18077 2.37739 7.56415 2.58524 7.90662 2.85016L7.97446 2.90401L7.97877 2.90724L7.98308 2.91155C8.05388 2.97424 8.10539 3.05578 8.1316 3.14664C8.15781 3.23751 8.15763 3.33395 8.1311 3.42472C8.10457 3.51549 8.05277 3.59685 7.98175 3.65929C7.91073 3.72173 7.82342 3.7627 7.73 3.77739C7.60531 3.79735 7.47768 3.76967 7.37246 3.69985L7.36169 3.69339L7.352 3.68585C7.08527 3.46715 6.78291 3.29594 6.45815 3.1797H6.45385L6.44954 3.17647C6.31942 3.12443 6.17447 3.12328 6.04354 3.17324C5.92077 3.23893 5.80662 3.39293 5.73877 3.68585C5.67415 3.9637 5.66123 4.33308 5.70431 4.77785L5.71292 4.86831C5.73015 5.02662 5.756 5.19355 5.78831 5.36693C6.21046 5.30985 6.63585 5.27216 7.06123 5.25385C7.66005 4.49455 8.34772 3.80977 9.10954 3.21416H9.11169L9.11277 3.21201C9.62754 2.82431 10.1358 2.54647 10.6075 2.41508C11.0792 2.28585 11.5358 2.29878 11.9149 2.52924L11.9214 2.53247L11.9289 2.53785C12.1083 2.66378 12.26 2.82503 12.3748 3.01169C12.4897 3.19836 12.5651 3.40652 12.5966 3.62339C12.6763 4.12524 12.658 4.6357 12.5428 5.13108C12.5148 5.25866 12.4379 5.37014 12.3285 5.44146C12.2191 5.51279 12.086 5.53823 11.958 5.51232C11.8299 5.48673 11.7169 5.41198 11.6432 5.30408C11.5695 5.19619 11.541 5.06373 11.5638 4.93508L11.5649 4.92862L11.5671 4.92216C11.6554 4.55385 11.6726 4.17262 11.6198 3.79678V3.79139C11.6101 3.70973 11.5843 3.6308 11.5441 3.5591C11.5038 3.4874 11.4498 3.42435 11.3851 3.37355C11.2709 3.30893 11.0792 3.29278 10.782 3.39185C10.4848 3.49308 10.1229 3.6977 9.72231 3.99924C9.23769 4.37724 8.78969 4.79616 8.37939 5.2517L8.472 5.25601H8.64646C10.3286 5.34108 11.8643 5.68031 12.9822 6.15416C13.5788 6.40724 14.0742 6.71201 14.4198 7.05878C14.7645 7.40555 14.9734 7.81155 14.9605 8.25632V8.28862L14.9583 8.30585C14.9012 8.70216 14.6998 9.06293 14.3929 9.32139C14.0527 9.61541 13.6624 9.84594 13.2406 10.002L13.2385 10.0031L13.2352 10.0042C13.113 10.0508 12.9774 10.0478 12.8573 9.99594C12.7372 9.94404 12.6421 9.84729 12.5923 9.72632C12.5675 9.66555 12.5551 9.60047 12.5556 9.53485C12.5562 9.46923 12.5698 9.40438 12.5957 9.34406C12.6215 9.28375 12.6591 9.22917 12.7062 9.18349C12.7533 9.13782 12.8091 9.10196 12.8702 9.07801L12.8723 9.07693L12.8755 9.07585C13.1866 8.96224 13.4748 8.79373 13.7263 8.57832L13.7317 8.57401C13.8477 8.48055 13.9283 8.3502 13.96 8.20462C13.9578 8.06785 13.8738 7.89232 13.6445 7.6877C13.4097 7.47878 13.0522 7.2677 12.5891 7.07062C11.5875 6.64416 10.1714 6.33508 8.58185 6.25216L8.42246 6.24462C8.13169 6.23278 7.84523 6.22847 7.56523 6.23278C7.36815 6.49447 7.17431 6.76908 6.98585 7.05447C6.82862 7.29355 6.68215 7.53262 6.54646 7.77278C6.64985 8.01508 6.76723 8.26278 6.89108 8.51262L6.95354 8.63539L7.01815 8.76462L7.08708 8.89601C7.79785 10.2432 8.63785 11.3535 9.41 12.0632L9.47892 12.1257C9.82354 12.4315 10.1402 12.6459 10.4105 12.7643C10.7034 12.8925 10.9005 12.8892 11.0254 12.8268C11.1535 12.7622 11.2666 12.6146 11.3334 12.3292C11.398 12.0439 11.4088 11.6594 11.3592 11.1877C11.2548 10.1635 10.8574 8.85293 10.1854 7.4917C10.1441 7.41731 10.1225 7.33357 10.1228 7.24847C10.1231 7.16338 10.1452 7.07979 10.187 7.00567C10.2288 6.93156 10.2889 6.86941 10.3616 6.82516C10.4343 6.78091 10.5171 6.75604 10.6022 6.75293C10.7033 6.74858 10.8035 6.77481 10.8896 6.82822C10.9756 6.88162 11.0436 6.95971 11.0846 7.05232C11.7997 8.50939 12.2369 9.9417 12.3554 11.0843L12.3662 11.1974C12.4146 11.7649 12.3823 12.2775 12.2552 12.6997C12.1185 13.1531 11.8675 13.5192 11.4755 13.7163C11.0814 13.9155 10.6215 13.8919 10.1595 13.7228C9.69646 13.5526 9.21185 13.2295 8.73369 12.7891C7.83985 11.9717 6.90292 10.7139 6.12539 9.20724L6.05539 9.0737C6.02206 9.01105 5.98975 8.94786 5.95846 8.88416C5.67991 9.47718 5.4592 10.0957 5.29939 10.7311C5.18631 11.2179 5.14862 11.6292 5.182 11.9405C5.21431 12.2474 5.308 12.4154 5.41569 12.494C5.57497 12.5715 5.75838 12.5831 5.92615 12.5263L5.93046 12.5242L5.93477 12.5231C6.32892 12.4046 6.69938 12.2162 7.02569 11.9674L7.02892 11.9652L7.03215 11.9631C7.1128 11.9068 7.2082 11.8755 7.30649 11.873C7.40478 11.8705 7.50164 11.897 7.58504 11.9491C7.66844 12.0011 7.7347 12.0766 7.77559 12.166C7.81649 12.2554 7.83022 12.3549 7.81508 12.452C7.79318 12.5801 7.72206 12.6945 7.61692 12.7708C7.19288 13.0899 6.71454 13.3296 6.20508 13.4783C5.9881 13.5469 5.75927 13.5699 5.53298 13.5458C5.30668 13.5217 5.08782 13.4511 4.89015 13.3383L4.88262 13.3351L4.87615 13.3308C4.50246 13.0831 4.29677 12.6739 4.21815 12.1892C4.13954 11.7079 4.18369 11.1317 4.32908 10.5049V10.5028L4.33015 10.4995C4.57892 9.5217 4.95369 8.57939 5.44369 7.69632C5.28877 7.30626 5.15221 6.90916 5.03446 6.50632C4.84062 6.55047 4.64892 6.60324 4.45938 6.66139C3.992 6.80893 3.628 6.98016 3.38246 7.16108C3.13585 7.34416 3.04538 7.50785 3.03785 7.63924V7.64462C3.03602 7.78511 3.08628 7.9213 3.17892 8.02693L3.19831 8.04847L3.20046 8.04955C3.42769 8.2897 3.698 8.48678 3.99738 8.62893L4.00169 8.63108L4.00492 8.63216C4.12207 8.69325 4.21032 8.79816 4.25046 8.92403C4.2906 9.0499 4.27938 9.18653 4.21923 9.30416C4.15875 9.42078 4.0547 9.50882 3.92967 9.54915C3.80465 9.58948 3.66876 9.57884 3.55154 9.51955C3.13909 9.32129 2.76757 9.04731 2.45631 8.71185C2.31763 8.5645 2.20934 8.39127 2.13765 8.20205C2.06595 8.01283 2.03225 7.81134 2.03846 7.60908V7.60478C2.06 7.16108 2.30338 6.78093 2.67385 6.47185C3.04323 6.16493 3.55369 5.91508 4.15785 5.72447H4.15892C4.37108 5.6577 4.58646 5.60062 4.80292 5.55108C4.76706 5.3627 4.73832 5.17302 4.71677 4.98247C4.64785 4.35678 4.67154 3.79031 4.80723 3.32939C4.94292 2.86631 5.19708 2.49047 5.59554 2.28908L5.59985 2.28693L5.602 2.28585C5.78508 2.1997 5.98323 2.15231 6.18462 2.1437ZM8.65077 7.02108C8.82432 7.03989 8.98969 7.10471 9.1298 7.20884C9.2699 7.31297 9.37965 7.45263 9.44769 7.61339C9.52152 7.79086 9.54067 7.98633 9.50268 8.17474C9.46469 8.36316 9.37129 8.53594 9.23446 8.67093C9.09777 8.80552 8.9245 8.89694 8.73624 8.93378C8.54797 8.97063 8.35303 8.95129 8.17568 8.87817C7.99832 8.80505 7.8464 8.68138 7.73881 8.52255C7.63122 8.36372 7.57273 8.17676 7.57062 7.98493C7.5697 7.79262 7.62633 7.60444 7.73322 7.44457C7.84012 7.28471 7.99239 7.16048 8.17046 7.08785C8.28896 7.03888 8.41593 7.01363 8.54415 7.01355H8.64323L8.65077 7.02108ZM6.29662 6.30493C6.20891 6.31433 6.12131 6.32474 6.03385 6.33616C6.05754 6.41908 6.08339 6.50201 6.11031 6.58708L6.15985 6.50955L6.29662 6.30493Z" fill="black"/>
+<path d="M5.68522 2.1437C5.88552 2.13508 6.08368 2.16739 6.27106 2.23631C6.68137 2.37739 7.06475 2.58524 7.40722 2.85016L7.47506 2.90401L7.47937 2.90724L7.48368 2.91155C7.55448 2.97424 7.60599 3.05578 7.6322 3.14664C7.65841 3.23751 7.65823 3.33395 7.6317 3.42472C7.60517 3.51549 7.55337 3.59685 7.48235 3.65929C7.41133 3.72173 7.32402 3.7627 7.2306 3.77739C7.10591 3.79735 6.97828 3.76967 6.87306 3.69985L6.86229 3.69339L6.8526 3.68585C6.58587 3.46715 6.28351 3.29594 5.95875 3.1797H5.95445L5.95014 3.17647C5.82002 3.12443 5.67507 3.12328 5.54414 3.17324C5.42137 3.23893 5.30722 3.39293 5.23937 3.68585C5.17475 3.9637 5.16183 4.33308 5.20491 4.77785L5.21352 4.86831C5.23075 5.02662 5.2566 5.19355 5.28891 5.36693C5.71106 5.30985 6.13645 5.27216 6.56183 5.25385C7.16065 4.49455 7.84832 3.80977 8.61014 3.21416H8.61229L8.61337 3.21201C9.12814 2.82431 9.6364 2.54647 10.1081 2.41508C10.5798 2.28585 11.0364 2.29878 11.4155 2.52924L11.422 2.53247L11.4295 2.53785C11.6089 2.66378 11.7606 2.82503 11.8754 3.01169C11.9903 3.19836 12.0657 3.40652 12.0972 3.62339C12.1769 4.12524 12.1586 4.6357 12.0434 5.13108C12.0154 5.25866 11.9385 5.37014 11.8291 5.44146C11.7197 5.51279 11.5866 5.53823 11.4586 5.51232C11.3305 5.48673 11.2175 5.41198 11.1438 5.30408C11.0701 5.19619 11.0416 5.06373 11.0644 4.93508L11.0655 4.92862L11.0677 4.92216C11.156 4.55385 11.1732 4.17262 11.1204 3.79678V3.79139C11.1107 3.70973 11.0849 3.6308 11.0447 3.5591C11.0044 3.4874 10.9504 3.42435 10.8857 3.37355C10.7715 3.30893 10.5798 3.29278 10.2826 3.39185C9.9854 3.49308 9.6235 3.6977 9.22291 3.99924C8.73829 4.37724 8.29029 4.79616 7.87999 5.2517L7.9726 5.25601H8.14706C9.8292 5.34108 11.3649 5.68031 12.4828 6.15416C13.0794 6.40724 13.5748 6.71201 13.9204 7.05878C14.2651 7.40555 14.474 7.81155 14.4611 8.25632V8.28862L14.4589 8.30585C14.4018 8.70216 14.2004 9.06293 13.8935 9.32139C13.5533 9.61541 13.163 9.84594 12.7412 10.002L12.7391 10.0031L12.7358 10.0042C12.6136 10.0508 12.478 10.0478 12.3579 9.99594C12.2378 9.94404 12.1427 9.84729 12.0929 9.72632C12.0681 9.66555 12.0557 9.60047 12.0562 9.53485C12.0568 9.46923 12.0704 9.40438 12.0963 9.34406C12.1221 9.28375 12.1597 9.22917 12.2068 9.18349C12.2539 9.13782 12.3097 9.10196 12.3708 9.07801L12.3729 9.07693L12.3761 9.07585C12.6872 8.96224 12.9754 8.79373 13.2269 8.57832L13.2323 8.57401C13.3483 8.48055 13.4289 8.3502 13.4606 8.20462C13.4584 8.06785 13.3744 7.89232 13.1451 7.6877C12.9103 7.47878 12.5528 7.2677 12.0897 7.07062C11.0881 6.64416 9.672 6.33508 8.08245 6.25216L7.92306 6.24462C7.63229 6.23278 7.34583 6.22847 7.06583 6.23278C6.86875 6.49447 6.67491 6.76908 6.48645 7.05447C6.32922 7.29355 6.18275 7.53262 6.04706 7.77278C6.15045 8.01508 6.26783 8.26278 6.39168 8.51262L6.45414 8.63539L6.51875 8.76462L6.58768 8.89601C7.29845 10.2432 8.13845 11.3535 8.9106 12.0632L8.97952 12.1257C9.32414 12.4315 9.6408 12.6459 9.9111 12.7643C10.204 12.8925 10.4011 12.8892 10.526 12.8268C10.6541 12.7622 10.7672 12.6146 10.834 12.3292C10.8986 12.0439 10.9094 11.6594 10.8598 11.1877C10.7554 10.1635 10.358 8.85293 9.686 7.4917C9.6447 7.41731 9.6231 7.33357 9.6234 7.24847C9.6237 7.16338 9.6458 7.07979 9.6876 7.00567C9.7294 6.93156 9.7895 6.86941 9.8622 6.82516C9.9349 6.78091 10.0177 6.75604 10.1028 6.75293C10.2039 6.74858 10.3041 6.77481 10.3902 6.82822C10.4762 6.88162 10.5442 6.95971 10.5852 7.05232C11.3003 8.50939 11.7375 9.9417 11.856 11.0843L11.8668 11.1974C11.9152 11.7649 11.8829 12.2775 11.7558 12.6997C11.6191 13.1531 11.3681 13.5192 10.9761 13.7163C10.582 13.9155 10.1221 13.8919 9.6601 13.7228C9.19706 13.5526 8.71245 13.2295 8.23429 12.7891C7.34045 11.9717 6.40352 10.7139 5.62599 9.20724L5.55599 9.0737C5.52266 9.01105 5.49035 8.94786 5.45906 8.88416C5.18051 9.47718 4.9598 10.0957 4.79999 10.7311C4.68691 11.2179 4.64922 11.6292 4.6826 11.9405C4.71491 12.2474 4.8086 12.4154 4.91629 12.494C5.07557 12.5715 5.25898 12.5831 5.42675 12.5263L5.43106 12.5242L5.43537 12.5231C5.82952 12.4046 6.19998 12.2162 6.52629 11.9674L6.52952 11.9652L6.53275 11.9631C6.6134 11.9068 6.7088 11.8755 6.80709 11.873C6.90538 11.8705 7.00224 11.897 7.08564 11.9491C7.16904 12.0011 7.2353 12.0766 7.27619 12.166C7.31709 12.2554 7.33082 12.3549 7.31568 12.452C7.29378 12.5801 7.22266 12.6945 7.11752 12.7708C6.69348 13.0899 6.21514 13.3296 5.70568 13.4783C5.4887 13.5469 5.25987 13.5699 5.03358 13.5458C4.80728 13.5217 4.58842 13.4511 4.39075 13.3383L4.38322 13.3351L4.37675 13.3308C4.00306 13.0831 3.79737 12.6739 3.71875 12.1892C3.64014 11.7079 3.68429 11.1317 3.82968 10.5049V10.5028L3.83075 10.4995C4.07952 9.5217 4.45429 8.57939 4.94429 7.69632C4.78937 7.30626 4.65281 6.90916 4.53506 6.50632C4.34122 6.55047 4.14952 6.60324 3.95998 6.66139C3.4926 6.80893 3.1286 6.98016 2.88306 7.16108C2.63645 7.34416 2.54598 7.50785 2.53845 7.63924V7.64462C2.53662 7.78511 2.58688 7.9213 2.67952 8.02693L2.69891 8.04847L2.70106 8.04955C2.92829 8.2897 3.1986 8.48678 3.49798 8.62893L3.50229 8.63108L3.50552 8.63216C3.62267 8.69325 3.71092 8.79816 3.75106 8.92403C3.7912 9.0499 3.77998 9.18653 3.71983 9.30416C3.65935 9.42078 3.5553 9.50882 3.43027 9.54915C3.30525 9.58948 3.16936 9.57884 3.05214 9.51955C2.63969 9.32129 2.26817 9.04731 1.95691 8.71185C1.81823 8.5645 1.70994 8.39127 1.63825 8.20205C1.56655 8.01283 1.53285 7.81134 1.53906 7.60908V7.60478C1.5606 7.16108 1.80398 6.78093 2.17445 6.47185C2.54383 6.16493 3.05429 5.91508 3.65845 5.72447H3.65952C3.87168 5.6577 4.08706 5.60062 4.30352 5.55108C4.26766 5.3627 4.23892 5.17302 4.21737 4.98247C4.14845 4.35678 4.17214 3.79031 4.30783 3.32939C4.44352 2.86631 4.69768 2.49047 5.09614 2.28908L5.10045 2.28693L5.1026 2.28585C5.28568 2.1997 5.48383 2.15231 5.68522 2.1437ZM8.15137 7.02108C8.32492 7.03989 8.49029 7.10471 8.6304 7.20884C8.7705 7.31297 8.88025 7.45263 8.94829 7.61339C9.02212 7.79086 9.04127 7.98633 9.00328 8.17474C8.96529 8.36316 8.87189 8.53594 8.73506 8.67093C8.59837 8.80552 8.4251 8.89694 8.23684 8.93378C8.04857 8.97063 7.85363 8.95129 7.67628 8.87817C7.49892 8.80505 7.347 8.68138 7.23941 8.52255C7.13182 8.36372 7.07333 8.17676 7.07122 7.98493C7.0703 7.79262 7.12693 7.60444 7.23382 7.44457C7.34072 7.28471 7.49299 7.16048 7.67106 7.08785C7.78956 7.03888 7.91653 7.01363 8.04475 7.01355H8.14383L8.15137 7.02108ZM5.79722 6.30493C5.70951 6.31433 5.62191 6.32474 5.53445 6.33616C5.55814 6.41908 5.58399 6.50201 5.61091 6.58708L5.66045 6.50955L5.79722 6.30493Z" fill="#C6CAD0"/>
 </svg>
diff --git a/assets/icons/editor_cursor.svg b/assets/icons/editor_cursor.svg
index e20013917d3..28eea301f7b 100644
--- a/assets/icons/editor_cursor.svg
+++ b/assets/icons/editor_cursor.svg
@@ -1,3 +1,3 @@
 <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M13.2806 4.66818L8.26042 1.76982C8.09921 1.67673 7.9003 1.67673 7.73909 1.76982L2.71918 4.66818C2.58367 4.74642 2.5 4.89112 2.5 5.04785V10.8924C2.5 11.0489 2.58367 11.1938 2.71918 11.2721L7.73934 14.1704C7.90054 14.2635 8.09946 14.2635 8.26066 14.1704L13.2808 11.2721C13.4163 11.1938 13.5 11.0491 13.5 10.8924V5.04785C13.5 4.89136 13.4163 4.74642 13.2808 4.66818H13.2806ZM12.9653 5.28212L8.11901 13.676C8.08626 13.7326 7.99977 13.7095 7.99977 13.6439V8.14771C7.99977 8.03788 7.94107 7.9363 7.84586 7.88115L3.08613 5.13317C3.02957 5.10041 3.05266 5.0139 3.11818 5.0139H12.8106C12.9483 5.0139 13.0343 5.1631 12.9655 5.28236H12.9653V5.28212Z" fill="#C4CAD4"/>
+<path d="M13.2806 4.69807L8.26042 1.79971C8.09921 1.70662 7.9003 1.70662 7.73909 1.79971L2.71918 4.69807C2.58367 4.77631 2.5 4.92101 2.5 5.07774V10.9223C2.5 11.0788 2.58367 11.2237 2.71918 11.302L7.73934 14.2003C7.90054 14.2934 8.09946 14.2934 8.26066 14.2003L13.2808 11.302C13.4163 11.2237 13.5 11.079 13.5 10.9223V5.07774C13.5 4.92125 13.4161 4.77631 13.2806 4.69807ZM12.9653 5.31201L8.11901 13.7059C8.08626 13.7625 7.99977 13.7394 7.99977 13.6738V8.1776C7.99977 8.06777 7.94107 7.96619 7.84586 7.91104L3.08613 5.16306C3.02957 5.1303 3.05266 5.04379 3.11818 5.04379H12.8106C12.9483 5.04379 13.0341 5.19275 12.9653 5.31201Z" fill="#C6CAD0"/>
 </svg>
diff --git a/assets/icons/editor_emacs.svg b/assets/icons/editor_emacs.svg
index 951d7b2be16..3dbb2683969 100644
--- a/assets/icons/editor_emacs.svg
+++ b/assets/icons/editor_emacs.svg
@@ -1,10 +1,8 @@
 <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<g clip-path="url(#clip0_2716_663)">
-<path d="M8.47552 2.45453C11.5167 2.45457 13.9814 4.94501 13.9814 8.01623C13.9814 11.0875 11.5167 13.578 8.47552 13.5781C5.43427 13.5781 2.96948 11.0875 2.96948 8.01623C2.9695 4.94498 5.43429 2.45453 8.47552 2.45453ZM10.8795 4.70348C10.7605 4.16887 10.1328 3.85468 9.53627 3.96342C8.97622 4.06552 7.62871 4.45681 7.62057 4.45916C9.29414 4.44469 9.57429 4.4726 9.69939 4.64751C9.77324 4.7508 9.66576 4.89248 9.21944 4.96538C8.73515 5.04447 7.73014 5.13958 7.72343 5.14022C6.75441 5.19776 6.07177 5.20168 5.86705 5.63512C5.73334 5.91827 6.00968 6.16857 6.13082 6.32527C6.64271 6.89455 7.38215 7.20158 7.85809 7.42767C8.03716 7.51274 8.56257 7.67345 8.56257 7.67345C7.01855 7.58853 5.90474 8.06267 5.2514 8.60855C4.51246 9.29204 4.83937 10.1067 6.35327 10.6084C7.24742 10.9047 7.69094 11.0439 9.02473 10.9238C9.81031 10.8815 9.9342 10.9068 9.94203 10.9712C9.95275 11.062 9.06932 11.2874 8.82812 11.357C8.21455 11.534 6.60645 11.8913 6.59758 11.8932C6.60115 11.8935 7.06249 11.9257 7.65531 11.8735C7.89632 11.8522 8.81142 11.7624 9.49557 11.6123C9.49557 11.6123 10.3297 11.4338 10.7759 11.2693C11.2429 11.0973 11.497 10.9512 11.6113 10.7443C11.6063 10.7019 11.6465 10.5516 11.4313 10.4613C10.8807 10.2304 10.2423 10.2721 8.9789 10.2453C7.57789 10.1972 7.11184 9.9626 6.86356 9.77373C6.62548 9.58212 6.74518 9.05204 7.76528 8.5851C8.27917 8.33646 10.2935 7.87759 10.2935 7.87759C9.61511 7.54227 8.35014 6.95284 8.09005 6.82552C7.86199 6.71388 7.49701 6.54572 7.4179 6.34233C7.32824 6.14709 7.6297 5.97888 7.79813 5.9307C8.34057 5.77424 9.10635 5.67701 9.8033 5.66609C10.1536 5.66061 10.2105 5.63806 10.2105 5.63806C10.6939 5.55787 11.0121 5.22722 10.8795 4.70348Z" fill="black"/>
+<mask id="mask0_4385_22072" style="mask-type:luminance" maskUnits="userSpaceOnUse" x="2" y="2" width="12" height="12">
+<path d="M14 2H2V14H14V2Z" fill="white"/>
+</mask>
+<g mask="url(#mask0_4385_22072)">
+<path d="M7.97552 2.45453C11.0167 2.45457 13.4814 4.94501 13.4814 8.01623C13.4814 11.0875 11.0167 13.578 7.97552 13.5781C4.93427 13.5781 2.46948 11.0875 2.46948 8.01623C2.4695 4.94498 4.93429 2.45453 7.97552 2.45453ZM10.3795 4.70348C10.2605 4.16887 9.6328 3.85468 9.03627 3.96342C8.47622 4.06552 7.12871 4.45681 7.12057 4.45916C8.79414 4.44469 9.07429 4.4726 9.19939 4.64751C9.27324 4.7508 9.16576 4.89248 8.71944 4.96538C8.23515 5.04447 7.23014 5.13958 7.22343 5.14022C6.25441 5.19776 5.57177 5.20168 5.36705 5.63512C5.23334 5.91827 5.50968 6.16857 5.63082 6.32527C6.14271 6.89455 6.88215 7.20158 7.35809 7.42767C7.53716 7.51274 8.06257 7.67345 8.06257 7.67345C6.51855 7.58853 5.40474 8.06267 4.7514 8.60855C4.01246 9.29204 4.33937 10.1067 5.85327 10.6084C6.74742 10.9047 7.19094 11.0439 8.52473 10.9238C9.31031 10.8815 9.4342 10.9068 9.44203 10.9712C9.45275 11.062 8.56932 11.2874 8.32812 11.357C7.71455 11.534 6.10645 11.8913 6.09758 11.8932C6.10115 11.8935 6.56249 11.9257 7.15531 11.8735C7.39632 11.8522 8.31142 11.7624 8.99557 11.6123C8.99557 11.6123 9.8297 11.4338 10.2759 11.2693C10.7429 11.0973 10.997 10.9512 11.1113 10.7443C11.1063 10.7019 11.1465 10.5516 10.9313 10.4613C10.3807 10.2304 9.7423 10.2721 8.4789 10.2453C7.07789 10.1972 6.61184 9.9626 6.36356 9.77373C6.12548 9.58212 6.24518 9.05204 7.26528 8.5851C7.77917 8.33646 9.7935 7.87759 9.7935 7.87759C9.11511 7.54227 7.85014 6.95284 7.59005 6.82552C7.36199 6.71388 6.99701 6.54572 6.9179 6.34233C6.82824 6.14709 7.1297 5.97888 7.29813 5.9307C7.84057 5.77424 8.60635 5.67701 9.3033 5.66609C9.6536 5.66061 9.7105 5.63806 9.7105 5.63806C10.1939 5.55787 10.5121 5.22722 10.3795 4.70348Z" fill="#C6CAD0"/>
 </g>
-<defs>
-<clipPath id="clip0_2716_663">
-<rect width="12" height="12" fill="white" transform="translate(2.5 2)"/>
-</clipPath>
-</defs>
 </svg>
diff --git a/assets/icons/editor_jet_brains.svg b/assets/icons/editor_jet_brains.svg
index 7d9cf0c65cd..94d30903f6c 100644
--- a/assets/icons/editor_jet_brains.svg
+++ b/assets/icons/editor_jet_brains.svg
@@ -1,3 +1,3 @@
 <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M3.6725 13.9985C3.36161 13.9982 3.06354 13.8746 2.84371 13.6548C2.62388 13.435 2.50026 13.1369 2.5 12.826V7.494C2.5 6.8325 2.7675 6.185 3.2365 5.7165L6.219 2.736C6.45192 2.50247 6.72867 2.31724 7.03335 2.19094C7.33804 2.06464 7.66467 1.99975 7.9945 2H13.3275C13.6384 2.00027 13.9365 2.12388 14.1563 2.34371C14.3761 2.56354 14.4997 2.86162 14.5 3.1725V8.5045C14.4983 9.17074 14.2336 9.80936 13.7635 10.2815L10.781 13.264C10.5477 13.4976 10.2706 13.6829 9.96561 13.8092C9.66059 13.9355 9.33364 14.0003 9.0035 14V13.9985H3.6725ZM8.157 10.5715H5.243V11.257H8.157V10.5715ZM4.4815 5.257H11.243V12.0165L13.3715 9.888C13.7373 9.52036 13.9433 9.02316 13.9445 8.5045V3.1725C13.9445 2.8335 13.6685 2.5555 13.3275 2.5555H7.9945C7.73753 2.55499 7.483 2.6053 7.24556 2.70356C7.00813 2.80181 6.79246 2.94606 6.611 3.128L4.4815 5.257ZM4.3855 5.353L3.628 6.11C3.26258 6.47809 3.0569 6.97533 3.0555 7.494V12.826C3.0555 13.165 3.3315 13.443 3.6725 13.443H9.0055C9.26249 13.4434 9.51701 13.3929 9.75445 13.2946C9.99188 13.1963 10.2075 13.052 10.389 12.87L11.145 12.1145H4.3855V5.353Z" fill="black"/>
+<path d="M3.1725 13.9985C2.86161 13.9982 2.56354 13.8746 2.34371 13.6548C2.12388 13.435 2.00026 13.1369 2 12.826V7.494C2 6.8325 2.2675 6.185 2.7365 5.7165L5.719 2.736C5.95192 2.50247 6.22867 2.31724 6.53335 2.19094C6.83804 2.06464 7.16467 1.99975 7.4945 2H12.8275C13.1384 2.00027 13.4365 2.12388 13.6563 2.34371C13.8761 2.56354 13.9997 2.86162 14 3.1725V8.5045C13.9983 9.17074 13.7336 9.80936 13.2635 10.2815L10.281 13.264C10.0477 13.4976 9.7706 13.6829 9.46561 13.8092C9.16059 13.9355 8.83364 14.0003 8.5035 14V13.9985H3.1725ZM7.657 10.5715H4.743V11.257H7.657V10.5715ZM3.9815 5.257H10.743V12.0165L12.8715 9.888C13.2373 9.52036 13.4433 9.02316 13.4445 8.5045V3.1725C13.4445 2.8335 13.1685 2.5555 12.8275 2.5555H7.4945C7.23753 2.55499 6.983 2.6053 6.74556 2.70356C6.50813 2.80181 6.29246 2.94606 6.111 3.128L3.9815 5.257ZM3.8855 5.353L3.128 6.11C2.76258 6.47809 2.5569 6.97533 2.5555 7.494V12.826C2.5555 13.165 2.8315 13.443 3.1725 13.443H8.5055C8.76249 13.4434 9.01701 13.3929 9.25445 13.2946C9.49188 13.1963 9.7075 13.052 9.889 12.87L10.645 12.1145H3.8855V5.353Z" fill="#C6CAD0"/>
 </svg>
diff --git a/assets/icons/editor_sublime.svg b/assets/icons/editor_sublime.svg
index 95a04f6b541..92bf14977d4 100644
--- a/assets/icons/editor_sublime.svg
+++ b/assets/icons/editor_sublime.svg
@@ -1,5 +1,5 @@
 <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M13.0945 8.01611C13.0945 7.87619 12.9911 7.79551 12.8642 7.8356L4.13456 10.6038C4.00742 10.6441 3.90427 10.7904 3.90427 10.9301V13.7593C3.90427 13.8992 4.00742 13.9801 4.13456 13.9398L12.8642 11.1719C12.9911 11.1315 13.0945 10.9852 13.0945 10.8453V8.01611Z" fill="black"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M3.90427 7.92597C3.90427 8.06588 4.00742 8.21218 4.13456 8.25252L12.8655 11.0209C12.9926 11.0613 13.0958 10.9803 13.0958 10.8407V8.01124C13.0958 7.87158 12.9926 7.72529 12.8655 7.68494L4.13456 4.91652C4.00742 4.87618 3.90427 4.95686 3.90427 5.09677V7.92597Z" fill="black"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M13.0945 2.20248C13.0945 2.06256 12.9911 1.98163 12.8642 2.02197L4.13456 4.78988C4.00742 4.83022 3.90427 4.97652 3.90427 5.11644V7.94563C3.90427 8.08554 4.00742 8.16622 4.13456 8.12614L12.8642 5.35797C12.9911 5.31763 13.0945 5.17133 13.0945 5.03167V2.20248Z" fill="black"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M12.5945 8.03524C12.5945 7.89532 12.4911 7.81464 12.3642 7.85473L3.63453 10.6229C3.50739 10.6632 3.40424 10.8095 3.40424 10.9492V13.7784C3.40424 13.9183 3.50739 13.9992 3.63453 13.9589L12.3642 11.191C12.4911 11.1506 12.5945 11.0043 12.5945 10.8644V8.03524Z" fill="#C6CAD0"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M3.40424 7.9451C3.40424 8.08501 3.50739 8.23131 3.63453 8.27165L12.3655 11.04C12.4926 11.0804 12.5958 10.9994 12.5958 10.8598V8.03037C12.5958 7.89071 12.4926 7.74442 12.3655 7.70407L3.63453 4.93565C3.50739 4.89531 3.40424 4.97599 3.40424 5.1159V7.9451Z" fill="#C6CAD0"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M12.5945 2.22161C12.5945 2.08169 12.4911 2.00076 12.3642 2.0411L3.63453 4.80901C3.50739 4.84935 3.40424 4.99565 3.40424 5.13557V7.96476C3.40424 8.10467 3.50739 8.18535 3.63453 8.14527L12.3642 5.3771C12.4911 5.33676 12.5945 5.19046 12.5945 5.0508V2.22161Z" fill="#C6CAD0"/>
 </svg>
diff --git a/assets/icons/editor_vs_code.svg b/assets/icons/editor_vs_code.svg
index 2a71ad52af2..d1aef6fce4b 100644
--- a/assets/icons/editor_vs_code.svg
+++ b/assets/icons/editor_vs_code.svg
@@ -1,3 +1,3 @@
 <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M11.0094 13.9181C11.1984 13.9917 11.4139 13.987 11.6047 13.8952L14.0753 12.7064C14.3349 12.5814 14.5 12.3187 14.5 12.0305V3.9696C14.5 3.68136 14.3349 3.41862 14.0753 3.2937L11.6047 2.10485C11.3543 1.98438 11.0614 2.01389 10.8416 2.17363C10.8102 2.19645 10.7803 2.22193 10.7523 2.25001L6.02261 6.56498L3.96246 5.00115C3.77068 4.85558 3.50244 4.86751 3.32432 5.02953L2.66356 5.63059C2.44569 5.82877 2.44544 6.17152 2.66302 6.37004L4.44965 8.00001L2.66302 9.62998C2.44544 9.82849 2.44569 10.1713 2.66356 10.3694L3.32432 10.9705C3.50244 11.1325 3.77068 11.1444 3.96246 10.9989L6.02261 9.43504L10.7523 13.75C10.8271 13.8249 10.915 13.8812 11.0094 13.9181ZM11.5018 5.27587L7.91309 8.00001L11.5018 10.7241V5.27587Z" fill="black"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M10.5094 13.9181C10.6984 13.9917 10.9139 13.987 11.1047 13.8952L13.5753 12.7064C13.8349 12.5814 14 12.3187 14 12.0305V3.9696C14 3.68136 13.8349 3.41862 13.5753 3.2937L11.1047 2.10485C10.8543 1.98438 10.5614 2.01389 10.3416 2.17363C10.3102 2.19645 10.2803 2.22193 10.2523 2.25001L5.52261 6.56498L3.46246 5.00115C3.27068 4.85558 3.00244 4.86751 2.82432 5.02953L2.16356 5.63059C1.94569 5.82877 1.94544 6.17152 2.16302 6.37004L3.94965 8.00001L2.16302 9.62998C1.94544 9.82849 1.94569 10.1713 2.16356 10.3694L2.82432 10.9705C3.00244 11.1325 3.27068 11.1444 3.46246 10.9989L5.52261 9.43504L10.2523 13.75C10.3271 13.8249 10.415 13.8812 10.5094 13.9181ZM11.0018 5.27587L7.41309 8.00001L11.0018 10.7241V5.27587Z" fill="#C6CAD0"/>
 </svg>
diff --git a/assets/icons/share.svg b/assets/icons/share.svg
new file mode 100644
index 00000000000..00d2d09b93b
--- /dev/null
+++ b/assets/icons/share.svg
@@ -0,0 +1,5 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M7.99689 2.05652L7.99929 9.98113" stroke="#C6CAD0" stroke-width="1.17299" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M11.1699 5.22637L8.00001 2.05652L4.83015 5.22637" stroke="#C6CAD0" stroke-width="1.17299" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M3.24522 8L3.24522 12.2653C3.24522 12.7104 3.37046 13.1372 3.59338 13.4519C3.81631 13.7667 4.11866 13.9435 4.43392 13.9435H11.5661C11.8813 13.9435 12.1837 13.7667 12.4066 13.4519C12.6295 13.1372 12.7548 12.7104 12.7548 12.2653V8" stroke="#C6CAD0" stroke-width="1.17299" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
diff --git a/crates/icons/src/icons.rs b/crates/icons/src/icons.rs
index d67c4f76e62..83a7a1e9c4e 100644
--- a/crates/icons/src/icons.rs
+++ b/crates/icons/src/icons.rs
@@ -218,6 +218,7 @@ pub enum IconName {
     Send,
     Server,
     Settings,
+    Share,
     Shift,
     SignalHigh,
     SignalLow,

From 589dc95c87e8a39c4a7d1f146df393bd2ef6d639 Mon Sep 17 00:00:00 2001
From: Ben Brandt <benjamin.j.brandt@gmail.com>
Date: Tue, 19 May 2026 16:07:09 +0200
Subject: [PATCH 027/105] agent_ui: Restore last active agent panel entry
 (#57150)

Makes sure we can reload the last terminal, and also keeps track more
globally what your last agent type was so we can carry that over to new
workspaces

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Release Notes:

- N/A
---
 crates/agent_ui/src/agent_panel.rs            | 686 ++++++++++++++++--
 .../src/terminal_thread_metadata_store.rs     |  55 +-
 crates/agent_ui/src/thread_metadata_store.rs  |   6 +
 3 files changed, 649 insertions(+), 98 deletions(-)

diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs
index f13415d0cd5..151a04d8bf3 100644
--- a/crates/agent_ui/src/agent_panel.rs
+++ b/crates/agent_ui/src/agent_panel.rs
@@ -94,6 +94,7 @@ use workspace::{
 const AGENT_PANEL_KEY: &str = "agent_panel";
 const MIN_PANEL_WIDTH: Pixels = px(300.);
 const LAST_USED_AGENT_KEY: &str = "agent_panel__last_used_external_agent";
+const LAST_CREATED_ENTRY_KIND_KEY: &str = "agent_panel__last_created_entry_kind";
 const TERMINAL_AGENT_TELEMETRY_ID: &str = "terminal";
 
 /// Maximum number of idle threads kept in the agent panel's retained list.
@@ -145,6 +146,11 @@ struct LastUsedAgent {
     agent: Agent,
 }
 
+#[derive(Serialize, Deserialize)]
+struct LastCreatedEntryKind {
+    entry_kind: AgentPanelEntryKind,
+}
+
 /// Reads the most recently used agent across all workspaces. Used as a fallback
 /// when opening a workspace that has no per-workspace agent preference yet.
 fn read_global_last_used_agent(kvp: &KeyValueStore) -> Option<Agent> {
@@ -163,6 +169,22 @@ async fn write_global_last_used_agent(kvp: KeyValueStore, agent: Agent) {
     }
 }
 
+fn read_global_last_created_entry_kind(kvp: &KeyValueStore) -> Option<AgentPanelEntryKind> {
+    kvp.read_kvp(LAST_CREATED_ENTRY_KIND_KEY)
+        .log_err()
+        .flatten()
+        .and_then(|json| serde_json::from_str::<LastCreatedEntryKind>(&json).log_err())
+        .map(|entry| entry.entry_kind)
+}
+
+async fn write_global_last_created_entry_kind(kvp: KeyValueStore, entry_kind: AgentPanelEntryKind) {
+    if let Some(json) = serde_json::to_string(&LastCreatedEntryKind { entry_kind }).log_err() {
+        kvp.write_kvp(LAST_CREATED_ENTRY_KIND_KEY.to_string(), json)
+            .await
+            .log_err();
+    }
+}
+
 fn read_serialized_panel(
     workspace_id: workspace::WorkspaceId,
     kvp: &KeyValueStore,
@@ -211,6 +233,8 @@ struct SerializedAgentPanel {
     #[serde(default)]
     last_active_thread: Option<SerializedActiveThread>,
     #[serde(default)]
+    last_active_terminal_id: Option<String>,
+    #[serde(default)]
     new_draft_thread_id: Option<ThreadId>,
 }
 
@@ -844,6 +868,7 @@ pub struct AgentPanel {
     draft_thread: Option<Entity<ConversationView>>,
     retained_threads: HashMap<ThreadId, Entity<ConversationView>>,
     terminals: HashMap<TerminalId, AgentTerminal>,
+    pending_terminal_spawn: Option<TerminalId>,
     new_thread_menu_handle: PopoverMenuHandle<ContextMenu>,
     agent_panel_menu_handle: PopoverMenuHandle<ContextMenu>,
     _extension_subscription: Option<Subscription>,
@@ -872,52 +897,58 @@ impl AgentPanel {
 
         let selected_agent = self.selected_agent.clone();
         let last_created_entry_kind = self.last_created_entry_kind;
+        let last_active_terminal_id = self
+            .active_terminal_id()
+            .map(|terminal_id| terminal_id.to_key_string());
 
-        let is_draft_active = self.active_thread_is_draft(cx);
-        let active_thread_id = self.active_thread_id(cx);
-        let active_thread_agent = self
-            .active_conversation_view()
-            .map(|cv| cv.read(cx).agent_key().clone())
-            .unwrap_or_else(|| self.selected_agent.clone());
-        let last_active_thread = self
-            .active_agent_thread(cx)
-            .map(|thread| {
-                let thread = thread.read(cx);
+        let last_active_thread = if last_active_terminal_id.is_some() {
+            None
+        } else {
+            let is_draft_active = self.active_thread_is_draft(cx);
+            let active_thread_id = self.active_thread_id(cx);
+            let active_thread_agent = self
+                .active_conversation_view()
+                .map(|cv| cv.read(cx).agent_key().clone())
+                .unwrap_or_else(|| self.selected_agent.clone());
+            self.active_agent_thread(cx)
+                .map(|thread| {
+                    let thread = thread.read(cx);
 
-                let title = thread.title();
-                let work_dirs = thread.work_dirs().cloned();
-                SerializedActiveThread {
-                    session_id: (!is_draft_active).then(|| thread.session_id().0.to_string()),
-                    thread_id: active_thread_id,
-                    agent_type: active_thread_agent.clone(),
-                    title: title.map(|t| t.to_string()),
-                    work_dirs: work_dirs.map(|dirs| dirs.serialize()),
-                }
-            })
-            .or_else(|| {
-                // The active view may be in `Loading` or `LoadError` — for
-                // example, while a restored thread is waiting for a custom
-                // agent to finish registering. Without this fallback, a
-                // stray `serialize()` triggered during that window would
-                // write `session_id=None` and wipe the restored session
-                if is_draft_active {
-                    return None;
-                }
-                let conversation_view = self.active_conversation_view()?;
-                let session_id = conversation_view.read(cx).root_session_id.clone()?;
-                let metadata = ThreadMetadataStore::try_global(cx)
-                    .and_then(|store| store.read(cx).entry_by_session(&session_id).cloned());
-                Some(SerializedActiveThread {
-                    session_id: Some(session_id.0.to_string()),
-                    thread_id: active_thread_id,
-                    agent_type: active_thread_agent.clone(),
-                    title: metadata
-                        .as_ref()
-                        .and_then(|m| m.title.as_ref())
-                        .map(|t| t.to_string()),
-                    work_dirs: metadata.map(|m| m.folder_paths().serialize()),
+                    let title = thread.title();
+                    let work_dirs = thread.work_dirs().cloned();
+                    SerializedActiveThread {
+                        session_id: (!is_draft_active).then(|| thread.session_id().0.to_string()),
+                        thread_id: active_thread_id,
+                        agent_type: active_thread_agent.clone(),
+                        title: title.map(|t| t.to_string()),
+                        work_dirs: work_dirs.map(|dirs| dirs.serialize()),
+                    }
                 })
-            });
+                .or_else(|| {
+                    // The active view may be in `Loading` or `LoadError` — for
+                    // example, while a restored thread is waiting for a custom
+                    // agent to finish registering. Without this fallback, a
+                    // stray `serialize()` triggered during that window would
+                    // write `session_id=None` and wipe the restored session
+                    if is_draft_active {
+                        return None;
+                    }
+                    let conversation_view = self.active_conversation_view()?;
+                    let session_id = conversation_view.read(cx).root_session_id.clone()?;
+                    let metadata = ThreadMetadataStore::try_global(cx)
+                        .and_then(|store| store.read(cx).entry_by_session(&session_id).cloned());
+                    Some(SerializedActiveThread {
+                        session_id: Some(session_id.0.to_string()),
+                        thread_id: active_thread_id,
+                        agent_type: active_thread_agent.clone(),
+                        title: metadata
+                            .as_ref()
+                            .and_then(|m| m.title.as_ref())
+                            .map(|t| t.to_string()),
+                        work_dirs: metadata.map(|m| m.folder_paths().serialize()),
+                    })
+                })
+        };
 
         let new_draft_thread_id = self
             .draft_thread
@@ -932,6 +963,7 @@ impl AgentPanel {
                     selected_agent: Some(selected_agent),
                     last_created_entry_kind,
                     last_active_thread,
+                    last_active_terminal_id,
                     new_draft_thread_id,
                 },
                 kvp,
@@ -957,7 +989,7 @@ impl AgentPanel {
                 .ok()
                 .flatten();
 
-            let (serialized_panel, global_last_used_agent) = cx
+            let (serialized_panel, global_last_used_agent, global_last_created_entry_kind) = cx
                 .background_spawn(async move {
                     match kvp {
                         Some(kvp) => {
@@ -965,9 +997,10 @@ impl AgentPanel {
                                 .and_then(|id| read_serialized_panel(id, &kvp))
                                 .or_else(|| read_legacy_serialized_panel(&kvp));
                             let global_agent = read_global_last_used_agent(&kvp);
-                            (panel, global_agent)
+                            let global_entry_kind = read_global_last_created_entry_kind(&kvp);
+                            (panel, global_agent, global_entry_kind)
                         }
-                        None => (None, None),
+                        None => (None, None, None),
                     }
                 })
                 .await;
@@ -975,33 +1008,15 @@ impl AgentPanel {
             let has_open_project = workspace
                 .read_with(cx, |workspace, cx| !workspace.root_paths(cx).is_empty())
                 .unwrap_or(false);
-            let thread_to_restore = if has_open_project {
+            let terminal_id_to_restore = if has_open_project {
                 serialized_panel
                     .as_ref()
-                    .and_then(|panel| panel.last_active_thread.as_ref())
-                    .and_then(|info| {
-                        let lookup = cx.update(|_window, cx| {
-                            let store = ThreadMetadataStore::global(cx);
-                            let store = store.read(cx);
-                            let primary = info.thread_id.and_then(|tid| store.entry(tid));
-                            let fallback = info.session_id.as_ref().and_then(|sid| {
-                                store.entry_by_session(&acp::SessionId::new(sid.clone()))
-                            });
-                            primary
-                                .or(fallback)
-                                .filter(|entry| !entry.archived)
-                                .map(|entry| entry.thread_id)
-                        });
-                        match lookup {
-                            Ok(Some(thread_id)) => Some((info, thread_id)),
-                            Ok(None) => {
-                                log::info!(
-                                    "last active thread is archived or missing, skipping restoration"
-                                );
-                                None
-                            }
-                            Err(err) => {
-                                log::warn!("failed to look up last active thread metadata: {err}");
+                    .and_then(|panel| panel.last_active_terminal_id.as_deref())
+                    .and_then(|terminal_id| {
+                        match TerminalId::from_key_string(terminal_id) {
+                            Ok(terminal_id) => Some(terminal_id),
+                            Err(error) => {
+                                log::warn!("failed to parse last active terminal id: {error}");
                                 None
                             }
                         }
@@ -1009,6 +1024,88 @@ impl AgentPanel {
             } else {
                 None
             };
+            let terminal_to_restore = if let Some(terminal_id) = terminal_id_to_restore {
+                match cx.update(|_window, cx| {
+                    TerminalThreadMetadataStore::try_global(cx).map(|store| {
+                        let reload_task = store.read(cx).reload_task();
+                        (store, reload_task)
+                    })
+                }) {
+                    Ok(Some((store, reload_task))) => {
+                        reload_task.await;
+                        match store
+                            .read_with(cx, |store, _cx| store.entry(terminal_id).cloned())
+                        {
+                            Some(metadata) => Some(metadata),
+                            None => {
+                                log::info!(
+                                    "last active terminal is missing, skipping restoration"
+                                );
+                                None
+                            }
+                        }
+                    }
+                    Ok(None) => {
+                        log::warn!("failed to restore active terminal: metadata store missing");
+                        None
+                    }
+                    Err(err) => {
+                        log::warn!("failed to access terminal metadata store: {err}");
+                        None
+                    }
+                }
+            } else {
+                None
+            };
+
+            let thread_to_restore = if has_open_project && terminal_to_restore.is_none() {
+                if let Some(info) = serialized_panel
+                    .as_ref()
+                    .and_then(|panel| panel.last_active_thread.as_ref())
+                {
+                    match cx.update(|_window, cx| {
+                        ThreadMetadataStore::try_global(cx).map(|store| {
+                            let reload_task = store.read(cx).reload_task();
+                            (store, reload_task)
+                        })
+                    }) {
+                        Ok(Some((store, reload_task))) => {
+                            reload_task.await;
+                            let thread_id = store.read_with(cx, |store, _cx| {
+                                let primary = info.thread_id.and_then(|tid| store.entry(tid));
+                                let fallback = info.session_id.as_ref().and_then(|sid| {
+                                    store.entry_by_session(&acp::SessionId::new(sid.clone()))
+                                });
+                                primary
+                                    .or(fallback)
+                                    .filter(|entry| !entry.archived)
+                                    .map(|entry| entry.thread_id)
+                            });
+                            match thread_id {
+                                Some(thread_id) => Some((info, thread_id)),
+                                None => {
+                                    log::info!(
+                                        "last active thread is archived or missing, skipping restoration"
+                                    );
+                                    None
+                                }
+                            }
+                        }
+                        Ok(None) => {
+                            log::warn!("failed to restore active thread: metadata store missing");
+                            None
+                        }
+                        Err(err) => {
+                            log::warn!("failed to access thread metadata store: {err}");
+                            None
+                        }
+                    }
+                } else {
+                    None
+                }
+            } else {
+                None
+            };
 
             let panel = workspace.update_in(cx, |workspace, window, cx| {
                 let panel = cx.new(|cx| Self::new(workspace, prompt_store, window, cx));
@@ -1030,6 +1127,8 @@ impl AgentPanel {
 
                     if let Some(serialized_panel) = &serialized_panel {
                         panel.last_created_entry_kind = serialized_panel.last_created_entry_kind;
+                    } else if let Some(entry_kind) = global_last_created_entry_kind {
+                        panel.last_created_entry_kind = entry_kind;
                     }
 
                     // The thread being restored may have been bound to an
@@ -1051,7 +1150,16 @@ impl AgentPanel {
                         panel.selected_agent = agent;
                     }
 
-                    if let Some((info, thread_id)) = thread_to_restore {
+                    if let Some(metadata) = terminal_to_restore {
+                        panel.restore_terminal_for_panel_load(
+                            metadata,
+                            false,
+                            AgentThreadSource::AgentPanel,
+                            Some(workspace),
+                            window,
+                            cx,
+                        );
+                    } else if let Some((info, thread_id)) = thread_to_restore {
                         let agent = panel.selected_agent.clone();
                         panel.load_agent_thread(
                             agent,
@@ -1178,6 +1286,7 @@ impl AgentPanel {
             draft_thread: None,
             retained_threads: HashMap::default(),
             terminals: HashMap::default(),
+            pending_terminal_spawn: None,
             new_thread_menu_handle: PopoverMenuHandle::default(),
             agent_panel_menu_handle: PopoverMenuHandle::default(),
 
@@ -1392,7 +1501,7 @@ impl AgentPanel {
             return;
         }
 
-        self.set_last_created_entry_kind(AgentPanelEntryKind::Thread, cx);
+        self.set_last_created_entry_kind_from_user_action(AgentPanelEntryKind::Thread, cx);
 
         // If the user is viewing a *parked* draft and the ephemeral
         // new-draft slot is occupied, pressing `+` should just focus the
@@ -1545,6 +1654,7 @@ impl AgentPanel {
         if !self.supports_terminal(cx) {
             return;
         }
+        self.set_last_created_entry_kind_from_user_action(AgentPanelEntryKind::Terminal, cx);
         let working_directory = self.terminal_working_directory(workspace, cx);
         self.spawn_terminal(
             TerminalId::new(),
@@ -1579,7 +1689,7 @@ impl AgentPanel {
             && self.project.read(cx).supports_terminal(cx)
     }
 
-    fn set_last_created_entry_kind(
+    fn set_last_created_entry_kind_from_user_action(
         &mut self,
         entry_kind: AgentPanelEntryKind,
         cx: &mut Context<Self>,
@@ -1588,6 +1698,14 @@ impl AgentPanel {
             self.last_created_entry_kind = entry_kind;
             self.serialize(cx);
         }
+
+        cx.background_spawn({
+            let kvp = KeyValueStore::global(cx);
+            async move {
+                write_global_last_created_entry_kind(kvp, entry_kind).await;
+            }
+        })
+        .detach();
     }
 
     fn spawn_terminal(
@@ -1619,6 +1737,13 @@ impl AgentPanel {
                     workspace
                         .update(cx, |workspace, cx| workspace.show_error(&error, cx))
                         .log_err();
+                    this.update(cx, |this, cx| {
+                        if this.pending_terminal_spawn == Some(terminal_id) {
+                            this.pending_terminal_spawn = None;
+                            cx.notify();
+                        }
+                    })
+                    .log_err();
                     return anyhow::Ok(());
                 }
             };
@@ -1711,7 +1836,9 @@ impl AgentPanel {
             notification_subscriptions: Vec::new(),
             _subscriptions: vec![view_subscription, terminal_subscription],
         };
-        self.set_last_created_entry_kind(AgentPanelEntryKind::Terminal, cx);
+        if self.pending_terminal_spawn == Some(terminal_id) {
+            self.pending_terminal_spawn = None;
+        }
         terminal.refresh_metadata(cx);
         self.terminals.insert(terminal_id, terminal);
         self.persist_terminal_metadata(terminal_id, cx);
@@ -1773,6 +1900,9 @@ impl AgentPanel {
     ) {
         let was_active = self.active_terminal_id() == Some(terminal_id);
 
+        if self.pending_terminal_spawn == Some(terminal_id) {
+            self.pending_terminal_spawn = None;
+        }
         self.dismiss_terminal_notifications(terminal_id, cx);
         if self.terminals.remove(&terminal_id).is_none() {
             return;
@@ -1882,6 +2012,7 @@ impl AgentPanel {
             return;
         }
 
+        self.pending_terminal_spawn = Some(metadata.terminal_id);
         let working_directory = self.terminal_restore_working_directory(&metadata, workspace, cx);
         let initial_title = Self::terminal_restore_initial_title(&metadata);
         self.spawn_terminal(
@@ -1898,6 +2029,23 @@ impl AgentPanel {
         );
     }
 
+    fn restore_terminal_for_panel_load(
+        &mut self,
+        metadata: TerminalThreadMetadata,
+        focus: bool,
+        source: AgentThreadSource,
+        workspace: Option<&Workspace>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        #[cfg(test)]
+        self.restore_test_terminal(metadata, focus, source, workspace, window, cx)
+            .log_err();
+
+        #[cfg(not(test))]
+        self.restore_terminal(metadata, focus, source, workspace, window, cx);
+    }
+
     fn terminal_restore_working_directory(
         &self,
         metadata: &TerminalThreadMetadata,
@@ -4050,7 +4198,99 @@ impl Panel for AgentPanel {
 impl AgentPanel {
     fn ensure_thread_initialized(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         if matches!(self.base_view, BaseView::Uninitialized) {
-            self.activate_draft(false, AgentThreadSource::AgentPanel, window, cx);
+            if self.pending_terminal_spawn.is_some() {
+                return;
+            }
+            if self.should_create_terminal_for_new_entry(cx) {
+                let terminal_id = TerminalId::new();
+                self.pending_terminal_spawn = Some(terminal_id);
+                cx.defer_in(window, move |this, window, cx| {
+                    if matches!(this.base_view, BaseView::Uninitialized)
+                        && this.pending_terminal_spawn == Some(terminal_id)
+                        && this.should_create_terminal_for_new_entry(cx)
+                    {
+                        this.create_initial_terminal(
+                            terminal_id,
+                            AgentThreadSource::AgentPanel,
+                            window,
+                            cx,
+                        );
+                    } else if this.pending_terminal_spawn == Some(terminal_id) {
+                        this.pending_terminal_spawn = None;
+                    }
+                });
+            } else {
+                self.activate_draft(false, AgentThreadSource::AgentPanel, window, cx);
+            }
+        }
+    }
+
+    fn create_initial_terminal(
+        &mut self,
+        terminal_id: TerminalId,
+        source: AgentThreadSource,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if !self.supports_terminal(cx) {
+            if self.pending_terminal_spawn == Some(terminal_id) {
+                self.pending_terminal_spawn = None;
+            }
+            return;
+        }
+        let working_directory = self.terminal_working_directory(None, cx);
+        self.spawn_initial_terminal(terminal_id, working_directory, source, window, cx);
+    }
+
+    #[cfg(not(test))]
+    fn spawn_initial_terminal(
+        &mut self,
+        terminal_id: TerminalId,
+        working_directory: Option<PathBuf>,
+        source: AgentThreadSource,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.spawn_terminal(
+            terminal_id,
+            working_directory,
+            None,
+            None,
+            None,
+            true,
+            false,
+            source,
+            window,
+            cx,
+        );
+    }
+
+    #[cfg(test)]
+    fn spawn_initial_terminal(
+        &mut self,
+        terminal_id: TerminalId,
+        working_directory: Option<PathBuf>,
+        source: AgentThreadSource,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if let Err(error) = self.insert_display_only_terminal(
+            terminal_id,
+            working_directory,
+            None,
+            None,
+            None,
+            true,
+            false,
+            source,
+            window,
+            cx,
+        ) {
+            log::error!("failed to spawn test agent panel terminal: {error:#}");
+            if self.pending_terminal_spawn == Some(terminal_id) {
+                self.pending_terminal_spawn = None;
+                cx.notify();
+            }
         }
     }
 
@@ -5528,6 +5768,7 @@ impl AgentPanel {
         cx: &mut Context<Self>,
     ) -> Result<TerminalId> {
         let terminal_id = TerminalId::new();
+        self.set_last_created_entry_kind_from_user_action(AgentPanelEntryKind::Terminal, cx);
         self.insert_display_only_terminal(
             terminal_id,
             None,
@@ -5909,6 +6150,27 @@ mod tests {
         panel_b.update(cx, |panel, cx| panel.serialize(cx));
         cx.run_until_parked();
 
+        let workspace_a_id = workspace_a
+            .read_with(cx, |workspace, _cx| workspace.database_id())
+            .expect("workspace A should have a database id");
+        let kvp = cx.update(|_window, cx| KeyValueStore::global(cx));
+        let serialized_a: SerializedAgentPanel = cx
+            .background_spawn(async move { read_serialized_panel(workspace_a_id, &kvp) })
+            .await
+            .expect("workspace A should serialize panel state");
+        assert!(
+            serialized_a.last_active_thread.is_some(),
+            "active thread should be the thread restore target"
+        );
+        assert!(
+            serialized_a.last_active_terminal_id.is_none(),
+            "active thread serialization should not also include a terminal restore target"
+        );
+
+        cx.update(|_window, cx| {
+            ThreadMetadataStore::init_global(cx);
+        });
+
         // Load fresh panels for each workspace and verify independent state.
         let async_cx = cx.update(|window, cx| window.to_async(cx));
         let loaded_a = AgentPanel::load(workspace_a.downgrade(), async_cx)
@@ -5950,6 +6212,278 @@ mod tests {
         });
     }
 
+    #[gpui::test]
+    async fn test_active_terminal_serialize_and_load_round_trip(cx: &mut TestAppContext) {
+        init_test(cx);
+        cx.update(|cx| {
+            agent::ThreadStore::init_global(cx);
+            TerminalThreadMetadataStore::init_global(cx);
+            language_model::LanguageModelRegistry::test(cx);
+        });
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree("/project", json!({ "file.txt": "" })).await;
+        cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));
+        let project = Project::test(fs.clone(), [Path::new("/project")], cx).await;
+
+        let multi_workspace =
+            cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
+        let workspace = multi_workspace
+            .read_with(cx, |multi_workspace, _cx| {
+                multi_workspace.workspace().clone()
+            })
+            .unwrap();
+        workspace.update(cx, |workspace, _cx| {
+            workspace.set_random_database_id();
+        });
+
+        let cx = &mut VisualTestContext::from_window(multi_workspace.into(), cx);
+        let panel = workspace.update_in(cx, |workspace, window, cx| {
+            cx.new(|cx| AgentPanel::new(workspace, None, window, cx))
+        });
+
+        panel.update_in(cx, |panel, window, cx| {
+            panel.activate_new_thread(false, AgentThreadSource::AgentPanel, window, cx);
+        });
+        let terminal_id = panel
+            .update_in(cx, |panel, window, cx| {
+                panel.insert_test_terminal("Dev Server", true, window, cx)
+            })
+            .expect("test terminal should be inserted");
+        panel.update(cx, |panel, cx| panel.serialize(cx));
+        cx.run_until_parked();
+
+        let workspace_id = workspace
+            .read_with(cx, |workspace, _cx| workspace.database_id())
+            .expect("workspace should have a database id");
+        let kvp = cx.update(|_window, cx| KeyValueStore::global(cx));
+        let serialized: SerializedAgentPanel = cx
+            .background_spawn(async move { read_serialized_panel(workspace_id, &kvp) })
+            .await
+            .expect("workspace should serialize panel state");
+        assert_eq!(
+            serialized.last_active_terminal_id,
+            Some(terminal_id.to_key_string())
+        );
+        assert!(
+            serialized.last_active_thread.is_none(),
+            "active terminal serialization should not also include a thread restore target"
+        );
+
+        cx.update(|_window, cx| {
+            TerminalThreadMetadataStore::init_global(cx);
+        });
+        let async_cx = cx.update(|window, cx| window.to_async(cx));
+        let loaded = AgentPanel::load(workspace.downgrade(), async_cx)
+            .await
+            .expect("panel load should succeed");
+        for _ in 0..8 {
+            cx.run_until_parked();
+        }
+
+        loaded.read_with(cx, |panel, cx| {
+            assert_eq!(panel.active_terminal_id(), Some(terminal_id));
+            assert!(
+                panel.active_conversation_view().is_none(),
+                "the restored terminal should remain active instead of falling back to a draft"
+            );
+            assert!(
+                panel
+                    .terminals(cx)
+                    .into_iter()
+                    .any(|terminal| terminal.id == terminal_id),
+                "active terminal metadata should be restored into the loaded panel"
+            );
+        });
+    }
+
+    #[gpui::test]
+    async fn test_pending_terminal_restore_prevents_initial_terminal_creation(
+        cx: &mut TestAppContext,
+    ) {
+        let (panel, mut cx) = setup_panel(cx).await;
+
+        panel.update_in(&mut cx, |panel, window, cx| {
+            panel.last_created_entry_kind = AgentPanelEntryKind::Terminal;
+            panel.pending_terminal_spawn = Some(TerminalId::new());
+            panel.set_active(true, window, cx);
+        });
+        for _ in 0..4 {
+            cx.run_until_parked();
+        }
+
+        panel.read_with(&cx, |panel, cx| {
+            assert!(
+                panel.terminals(cx).is_empty(),
+                "activation while a terminal restore is pending should not create a second terminal"
+            );
+            assert!(
+                panel.active_conversation_view().is_none(),
+                "activation while a terminal restore is pending should not fall back to a draft"
+            );
+        });
+    }
+
+    #[gpui::test]
+    async fn test_repeated_activation_only_creates_one_initial_terminal(cx: &mut TestAppContext) {
+        let (panel, mut cx) = setup_panel(cx).await;
+
+        panel.update_in(&mut cx, |panel, window, cx| {
+            panel.last_created_entry_kind = AgentPanelEntryKind::Terminal;
+            panel.set_active(true, window, cx);
+            panel.set_active(true, window, cx);
+        });
+        for _ in 0..8 {
+            cx.run_until_parked();
+        }
+
+        panel.read_with(&cx, |panel, cx| {
+            assert_eq!(
+                panel.terminals(cx).len(),
+                1,
+                "repeated activation should only enqueue one initial terminal"
+            );
+            assert!(
+                panel.active_terminal_id().is_some(),
+                "the single initial terminal should become active"
+            );
+        });
+    }
+
+    #[gpui::test]
+    async fn test_restored_terminal_does_not_update_global_entry_kind(cx: &mut TestAppContext) {
+        let (panel, mut cx) = setup_panel(cx).await;
+        cx.update(|_, cx| {
+            TerminalThreadMetadataStore::init_global(cx);
+        });
+
+        panel.update_in(&mut cx, |panel, window, cx| {
+            panel.activate_new_thread(false, AgentThreadSource::AgentPanel, window, cx);
+        });
+        cx.run_until_parked();
+        cx.update(|_, cx| {
+            assert_eq!(
+                read_global_last_created_entry_kind(&KeyValueStore::global(cx)),
+                Some(AgentPanelEntryKind::Thread)
+            );
+        });
+
+        let metadata = TerminalThreadMetadata {
+            terminal_id: TerminalId::new(),
+            title: "Restored Terminal".into(),
+            custom_title: None,
+            created_at: Utc::now(),
+            worktree_paths: WorktreePaths::from_folder_paths(&PathList::new(&[PathBuf::from(
+                "/project",
+            )])),
+            remote_connection: None,
+            working_directory: None,
+        };
+        panel
+            .update_in(&mut cx, |panel, window, cx| {
+                panel.restore_test_terminal(
+                    metadata,
+                    true,
+                    AgentThreadSource::AgentPanel,
+                    None,
+                    window,
+                    cx,
+                )
+            })
+            .expect("test terminal should be restored");
+        cx.run_until_parked();
+
+        cx.update(|_, cx| {
+            assert_eq!(
+                read_global_last_created_entry_kind(&KeyValueStore::global(cx)),
+                Some(AgentPanelEntryKind::Thread),
+                "restoring a terminal should not change the global new-entry default"
+            );
+        });
+    }
+
+    #[gpui::test]
+    async fn test_new_workspace_load_uses_global_terminal_entry_kind(cx: &mut TestAppContext) {
+        init_test(cx);
+        cx.update(|cx| {
+            agent::ThreadStore::init_global(cx);
+            TerminalThreadMetadataStore::init_global(cx);
+            language_model::LanguageModelRegistry::test(cx);
+        });
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree("/project-a", json!({ "file.txt": "" }))
+            .await;
+        fs.insert_tree("/project-b", json!({ "file.txt": "" }))
+            .await;
+        cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));
+
+        let project_a = Project::test(fs.clone(), [Path::new("/project-a")], cx).await;
+        let project_b = Project::test(fs.clone(), [Path::new("/project-b")], cx).await;
+        let multi_workspace =
+            cx.add_window(|window, cx| MultiWorkspace::test_new(project_a.clone(), window, cx));
+        let multi_workspace_entity = multi_workspace.root(cx).unwrap();
+        let workspace_a = multi_workspace
+            .read_with(cx, |multi_workspace, _cx| {
+                multi_workspace.workspace().clone()
+            })
+            .unwrap();
+        workspace_a.update(cx, |workspace, _cx| {
+            workspace.set_random_database_id();
+        });
+
+        let cx = &mut VisualTestContext::from_window(multi_workspace.into(), cx);
+        let panel_a = workspace_a.update_in(cx, |workspace, window, cx| {
+            cx.new(|cx| AgentPanel::new(workspace, None, window, cx))
+        });
+        panel_a
+            .update_in(cx, |panel, window, cx| {
+                panel.insert_test_terminal("Dev Server", true, window, cx)
+            })
+            .expect("test terminal should be inserted");
+        cx.run_until_parked();
+
+        cx.update(|_window, cx| {
+            assert_eq!(
+                read_global_last_created_entry_kind(&KeyValueStore::global(cx)),
+                Some(AgentPanelEntryKind::Terminal)
+            );
+        });
+
+        let workspace_b = multi_workspace_entity.update_in(cx, |multi_workspace, window, cx| {
+            multi_workspace.test_add_workspace(project_b.clone(), window, cx)
+        });
+        workspace_b.update(cx, |workspace, _cx| {
+            workspace.set_random_database_id();
+        });
+
+        let async_cx = cx.update(|window, cx| window.to_async(cx));
+        let loaded = AgentPanel::load(workspace_b.downgrade(), async_cx)
+            .await
+            .expect("panel load should succeed");
+        workspace_b.update_in(cx, |workspace, window, cx| {
+            workspace.add_panel(loaded.clone(), window, cx);
+        });
+        loaded.update_in(cx, |panel, window, cx| {
+            panel.set_active(true, window, cx);
+        });
+        for _ in 0..8 {
+            cx.run_until_parked();
+        }
+
+        loaded.read_with(cx, |panel, cx| {
+            assert!(
+                panel.active_terminal_id().is_some(),
+                "new workspace should initialize to a terminal when terminal was the globally last used entry kind"
+            );
+            assert!(
+                panel.active_conversation_view().is_none(),
+                "new workspace should not initialize to a draft when terminal is the global entry kind"
+            );
+            assert!(panel.should_create_terminal_for_new_entry(cx));
+        });
+    }
+
     #[gpui::test]
     async fn test_non_native_thread_without_metadata_is_not_restored(cx: &mut TestAppContext) {
         init_test(cx);
diff --git a/crates/agent_ui/src/terminal_thread_metadata_store.rs b/crates/agent_ui/src/terminal_thread_metadata_store.rs
index e3d5c9fdef8..c5e2dbbdfba 100644
--- a/crates/agent_ui/src/terminal_thread_metadata_store.rs
+++ b/crates/agent_ui/src/terminal_thread_metadata_store.rs
@@ -10,6 +10,7 @@ use db::{
     },
     sqlez_macros::sql,
 };
+use futures::{FutureExt, future::Shared};
 use gpui::{AppContext as _, Entity, Global, Task};
 use remote::{RemoteConnectionOptions, same_remote_connection_identity};
 use ui::{App, Context, SharedString};
@@ -69,6 +70,7 @@ pub struct TerminalThreadMetadataStore {
     terminals: HashMap<TerminalId, TerminalThreadMetadata>,
     terminals_by_paths: HashMap<PathList, HashSet<TerminalId>>,
     terminals_by_main_paths: HashMap<PathList, HashSet<TerminalId>>,
+    reload_task: Option<Shared<Task<()>>>,
     pending_terminal_ops_tx: async_channel::Sender<DbOperation>,
     _db_operations_task: Task<()>,
 }
@@ -125,6 +127,12 @@ impl TerminalThreadMetadataStore {
         self.terminals.values()
     }
 
+    pub fn reload_task(&self) -> Shared<Task<()>> {
+        self.reload_task
+            .clone()
+            .unwrap_or_else(|| Task::ready(()).shared())
+    }
+
     pub fn entries_for_path<'a>(
         &'a self,
         path_list: &PathList,
@@ -312,6 +320,7 @@ impl TerminalThreadMetadataStore {
             terminals: HashMap::default(),
             terminals_by_paths: HashMap::default(),
             terminals_by_main_paths: HashMap::default(),
+            reload_task: None,
             pending_terminal_ops_tx: tx,
             _db_operations_task,
         };
@@ -332,30 +341,32 @@ impl TerminalThreadMetadataStore {
 
     fn reload(&mut self, cx: &mut Context<Self>) {
         let db = self.db.clone();
-        cx.spawn(async move |this, cx| {
-            let rows = cx
-                .background_spawn(async move {
-                    db.list()
-                        .context("Failed to fetch terminal thread metadata")
+        self.reload_task = Some(
+            cx.spawn(async move |this, cx| {
+                let rows = cx
+                    .background_spawn(async move {
+                        db.list()
+                            .context("Failed to fetch terminal thread metadata")
+                    })
+                    .await
+                    .log_err()
+                    .unwrap_or_default();
+
+                this.update(cx, |this, cx| {
+                    this.terminals.clear();
+                    this.terminals_by_paths.clear();
+                    this.terminals_by_main_paths.clear();
+
+                    for row in rows {
+                        this.cache_terminal_metadata(row);
+                    }
+
+                    cx.notify();
                 })
-                .await
-                .log_err()
-                .unwrap_or_default();
-
-            this.update(cx, |this, cx| {
-                this.terminals.clear();
-                this.terminals_by_paths.clear();
-                this.terminals_by_main_paths.clear();
-
-                for row in rows {
-                    this.cache_terminal_metadata(row);
-                }
-
-                cx.notify();
+                .ok();
             })
-            .ok();
-        })
-        .detach();
+            .shared(),
+        );
     }
 }
 
diff --git a/crates/agent_ui/src/thread_metadata_store.rs b/crates/agent_ui/src/thread_metadata_store.rs
index 9787d3d9d7d..594b0d00b83 100644
--- a/crates/agent_ui/src/thread_metadata_store.rs
+++ b/crates/agent_ui/src/thread_metadata_store.rs
@@ -587,6 +587,12 @@ impl ThreadMetadataStore {
         self.threads.values()
     }
 
+    pub fn reload_task(&self) -> Shared<Task<()>> {
+        self.reload_task
+            .clone()
+            .unwrap_or_else(|| Task::ready(()).shared())
+    }
+
     /// Returns all archived threads.
     pub fn archived_entries(&self) -> impl Iterator<Item = &ThreadMetadata> + '_ {
         self.entries().filter(|t| t.archived)

From c5f6fca756fecbfb177f4f8b791483a7e1ebb9bb Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Tue, 19 May 2026 11:32:46 -0300
Subject: [PATCH 028/105] Don't show trust modal for linked worktrees if main
 is trusted (#57153)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Follow up to https://github.com/zed-industries/zed/pull/57056 — This PR
ensures we're refreshing the security modal so that it consumes the
trust given to the main worktree when creating a new linked (Git)
worktree.

Release Notes:

- N/A
---
 crates/git_ui/src/worktree_service.rs  | 120 +++++++++++++++++++++++++
 crates/workspace/src/security_modal.rs |   7 +-
 crates/workspace/src/workspace.rs      |   2 +-
 3 files changed, 127 insertions(+), 2 deletions(-)

diff --git a/crates/git_ui/src/worktree_service.rs b/crates/git_ui/src/worktree_service.rs
index 1eda4219092..e5301af3457 100644
--- a/crates/git_ui/src/worktree_service.rs
+++ b/crates/git_ui/src/worktree_service.rs
@@ -282,6 +282,15 @@ fn maybe_propagate_worktree_trust(
         }
     })
     .ok();
+
+    // After trust propagation, refresh the security modal on the new workspace
+    // so it dismisses itself if there are no more restricted worktrees.
+    cx.update(|window, cx| {
+        new_workspace.update(cx, |workspace, cx| {
+            workspace.show_worktree_trust_security_modal(false, window, cx);
+        });
+    })
+    .ok();
 }
 
 /// Handles the `CreateWorktree` action generically, without any agent panel involvement.
@@ -1011,4 +1020,115 @@ mod tests {
             "switching back to the main worktree should not rerun create_worktree hooks"
         );
     }
+
+    #[gpui::test]
+    async fn test_linked_worktree_inherits_trust_from_main_worktree(cx: &mut TestAppContext) {
+        init_test(cx);
+        cx.update(|cx| {
+            project::trusted_worktrees::init(collections::HashMap::default(), cx);
+        });
+
+        let fs = FakeFs::new(cx.background_executor.clone());
+        cx.update(|cx| <dyn Fs>::set_global(fs.clone(), cx));
+        fs.insert_tree(
+            "/root",
+            json!({
+                "project": {
+                    ".git": {},
+                    "src": {
+                        "main.rs": "fn main() {}",
+                    },
+                },
+            }),
+        )
+        .await;
+
+        let main_project_root = PathBuf::from(path!("/root/project"));
+        let project =
+            Project::test_with_worktree_trust(fs.clone(), [main_project_root.as_path()], cx).await;
+        project
+            .update(cx, |project, cx| project.git_scans_complete(cx))
+            .await;
+
+        // The main worktree starts restricted; trust it explicitly
+        let worktree_store = project.read_with(cx, |project, _| project.worktree_store());
+        let main_worktree_id = worktree_store.read_with(cx, |store, cx| {
+            store
+                .worktrees()
+                .next()
+                .map(|wt| wt.read(cx).id())
+                .expect("should have a worktree")
+        });
+        let trusted_store = cx
+            .read(|cx| project::trusted_worktrees::TrustedWorktrees::try_get_global(cx))
+            .expect("trust store should exist");
+        trusted_store.update(cx, |store, cx| {
+            store.trust(
+                &worktree_store,
+                collections::HashSet::from_iter([project::trusted_worktrees::PathTrust::Worktree(
+                    main_worktree_id,
+                )]),
+                cx,
+            );
+        });
+
+        // Verify main worktree is now trusted
+        let has_restricted = cx.read(|cx| {
+            project::trusted_worktrees::TrustedWorktrees::has_restricted_worktrees(
+                &worktree_store,
+                cx,
+            )
+        });
+        assert!(
+            !has_restricted,
+            "main worktree should be trusted after explicit trust"
+        );
+
+        let (multi_workspace, cx) =
+            cx.add_window_view(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
+        multi_workspace.update(cx, |multi_workspace, cx| {
+            multi_workspace.retain_active_workspace(cx);
+        });
+
+        // Create a linked worktree from the trusted main worktree
+        let main_workspace = multi_workspace.read_with(cx, |mw, _| mw.workspace().clone());
+        main_workspace.update_in(cx, |workspace, window, cx| {
+            handle_create_worktree(
+                workspace,
+                &zed_actions::CreateWorktree {
+                    worktree_name: Some("feature".to_string()),
+                    branch_target: NewWorktreeBranchTarget::CurrentBranch,
+                },
+                window,
+                None,
+                cx,
+            );
+        });
+        cx.run_until_parked();
+
+        // The new workspace (linked worktree) should inherit trust
+        let new_workspace = multi_workspace.read_with(cx, |mw, _| mw.workspace().clone());
+        let new_worktree_store =
+            new_workspace.read_with(cx, |ws, cx| ws.project().read(cx).worktree_store());
+        let new_has_restricted = cx.read(|cx| {
+            project::trusted_worktrees::TrustedWorktrees::has_restricted_worktrees(
+                &new_worktree_store,
+                cx,
+            )
+        });
+        assert!(
+            !new_has_restricted,
+            "linked worktree should inherit trust from the main worktree"
+        );
+
+        // The security modal should not be showing
+        let has_modal = new_workspace.read_with(cx, |ws, cx| {
+            ws.active_modal::<workspace::security_modal::SecurityModal>(cx)
+                .is_some()
+        });
+        assert!(
+            !has_modal,
+            "security modal should not show for a linked worktree created from a trusted main worktree"
+        );
+    }
 }
diff --git a/crates/workspace/src/security_modal.rs b/crates/workspace/src/security_modal.rs
index 89ce2abfd66..378968fd1c0 100644
--- a/crates/workspace/src/security_modal.rs
+++ b/crates/workspace/src/security_modal.rs
@@ -364,7 +364,12 @@ impl SecurityModal {
                 if self.restricted_paths != new_restricted_worktrees {
                     self.trust_parents = false;
                     self.restricted_paths = new_restricted_worktrees;
-                    cx.notify();
+                    if self.restricted_paths.is_empty() {
+                        self.trusted = Some(true);
+                        self.dismiss(cx);
+                    } else {
+                        cx.notify();
+                    }
                 }
             }
         } else if !self.restricted_paths.is_empty() {
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 599a2d23681..0f529fc9362 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -15,7 +15,7 @@ pub mod path_list {
 }
 mod persistence;
 pub mod searchable;
-mod security_modal;
+pub mod security_modal;
 pub mod shared_screen;
 pub use shared_screen::SharedScreen;
 pub mod focus_follows_mouse;

From ad437c93c23f356f1466be3efa4b25a176f76636 Mon Sep 17 00:00:00 2001
From: Ben Brandt <benjamin.j.brandt@gmail.com>
Date: Tue, 19 May 2026 16:43:38 +0200
Subject: [PATCH 029/105] sidebar: Fix stale sidebar thread header state
 (#57017)

There was a case where if you archived or closed all threads, you
wouldn't see the empty state again.

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Release Notes:

- N/A
---
 crates/agent_ui/src/draft_prompt_store.rs |  2 +-
 crates/sidebar/src/sidebar.rs             | 87 +++++++++++++++------
 crates/sidebar/src/sidebar_tests.rs       | 92 +++++++++++++++++++++++
 3 files changed, 155 insertions(+), 26 deletions(-)

diff --git a/crates/agent_ui/src/draft_prompt_store.rs b/crates/agent_ui/src/draft_prompt_store.rs
index b32b8e811cf..34d17d49994 100644
--- a/crates/agent_ui/src/draft_prompt_store.rs
+++ b/crates/agent_ui/src/draft_prompt_store.rs
@@ -12,6 +12,7 @@ use agent_client_protocol::schema as acp;
 use anyhow::Context as _;
 use db::kvp::KeyValueStore;
 use gpui::{App, AppContext as _, Entity, Task};
+use itertools::Itertools;
 use ui::SharedString;
 use util::ResultExt as _;
 use workspace::Workspace;
@@ -128,7 +129,6 @@ pub fn display_label_for_draft(
             acp::ContentBlock::ResourceLink(link) => Some(link.uri.as_str()),
             _ => None,
         })
-        .collect::<Vec<_>>()
         .join(" ");
     truncate_draft_label(&raw)
 }
diff --git a/crates/sidebar/src/sidebar.rs b/crates/sidebar/src/sidebar.rs
index 735421f858d..a86960f3fb5 100644
--- a/crates/sidebar/src/sidebar.rs
+++ b/crates/sidebar/src/sidebar.rs
@@ -220,6 +220,32 @@ impl ThreadEntryWorkspace {
     }
 }
 
+fn draft_display_label_for_thread_metadata(
+    metadata: &ThreadMetadata,
+    workspace: &ThreadEntryWorkspace,
+    cx: &App,
+) -> Option<SharedString> {
+    let workspace = match workspace {
+        ThreadEntryWorkspace::Open(workspace) => Some(workspace),
+        ThreadEntryWorkspace::Closed { .. } => None,
+    };
+    agent_ui::draft_prompt_store::display_label_for_draft(workspace, metadata.thread_id, cx)
+}
+
+fn thread_metadata_would_render_sidebar_row(
+    metadata: &ThreadMetadata,
+    workspace: &ThreadEntryWorkspace,
+    hidden_draft_thread_ids: &HashSet<ThreadId>,
+    cx: &App,
+) -> bool {
+    if !metadata.is_draft() {
+        return true;
+    }
+
+    !hidden_draft_thread_ids.contains(&metadata.thread_id)
+        && draft_display_label_for_thread_metadata(metadata, workspace, cx).is_some()
+}
+
 #[derive(Clone)]
 struct ThreadEntry {
     metadata: ThreadMetadata,
@@ -1385,19 +1411,18 @@ impl Sidebar {
             let mut has_running_threads = false;
             let mut waiting_thread_count: usize = 0;
             let group_host = group_key.host();
+            let hidden_draft_thread_ids: HashSet<ThreadId> = group_workspaces
+                .iter()
+                .filter_map(|ws| {
+                    ws.read(cx)
+                        .panel::<AgentPanel>(cx)
+                        .and_then(|panel| panel.read(cx).ephemeral_draft_thread_id(cx))
+                })
+                .collect();
 
             if should_load_threads {
                 let thread_store = ThreadMetadataStore::global(cx);
 
-                let ephemeral_drafts: HashSet<ThreadId> = group_workspaces
-                    .iter()
-                    .filter_map(|ws| {
-                        ws.read(cx)
-                            .panel::<AgentPanel>(cx)
-                            .and_then(|panel| panel.read(cx).ephemeral_draft_thread_id(cx))
-                    })
-                    .collect();
-
                 let make_thread_entry =
                     |row: ThreadMetadata, workspace: ThreadEntryWorkspace| -> ThreadEntry {
                         let (icon, icon_from_external_svg) = resolve_agent_icon(&row.agent_id);
@@ -1503,20 +1528,18 @@ impl Sidebar {
                     }
                 }
 
-                if !ephemeral_drafts.is_empty() {
-                    threads.retain(|thread| !ephemeral_drafts.contains(&thread.metadata.thread_id));
+                if !hidden_draft_thread_ids.is_empty() {
+                    threads.retain(|thread| {
+                        !hidden_draft_thread_ids.contains(&thread.metadata.thread_id)
+                    });
                 }
                 for thread in &mut threads {
                     if !thread.is_draft {
                         continue;
                     }
-                    let workspace = match &thread.workspace {
-                        ThreadEntryWorkspace::Open(workspace) => Some(workspace),
-                        ThreadEntryWorkspace::Closed { .. } => None,
-                    };
-                    thread.metadata.title = agent_ui::draft_prompt_store::display_label_for_draft(
-                        workspace,
-                        thread.metadata.thread_id,
+                    thread.metadata.title = draft_display_label_for_thread_metadata(
+                        &thread.metadata,
+                        &thread.workspace,
                         cx,
                     );
                 }
@@ -1582,19 +1605,33 @@ impl Sidebar {
                 }
             }
 
-            let has_threads = if !threads.is_empty() || !terminals.is_empty() {
-                true
-            } else {
+            let has_visible_rows = !threads.is_empty() || !terminals.is_empty();
+            let has_stored_thread_rows = !should_load_threads && !has_visible_rows && {
                 let store = ThreadMetadataStore::global(cx).read(cx);
                 store
                     .entries_for_main_worktree_path(group_key.path_list(), group_host.as_ref())
-                    .next()
-                    .is_some()
+                    .any(|metadata| {
+                        let workspace = resolve_workspace(metadata.folder_paths());
+                        thread_metadata_would_render_sidebar_row(
+                            metadata,
+                            &workspace,
+                            &hidden_draft_thread_ids,
+                            cx,
+                        )
+                    })
                     || store
                         .entries_for_path(group_key.path_list(), group_host.as_ref())
-                        .next()
-                        .is_some()
+                        .any(|metadata| {
+                            let workspace = resolve_workspace(metadata.folder_paths());
+                            thread_metadata_would_render_sidebar_row(
+                                metadata,
+                                &workspace,
+                                &hidden_draft_thread_ids,
+                                cx,
+                            )
+                        })
             };
+            let has_threads = has_visible_rows || has_stored_thread_rows;
 
             if !query.is_empty() {
                 let workspace_highlight_positions =
diff --git a/crates/sidebar/src/sidebar_tests.rs b/crates/sidebar/src/sidebar_tests.rs
index cb385828dc6..982f0c6cd24 100644
--- a/crates/sidebar/src/sidebar_tests.rs
+++ b/crates/sidebar/src/sidebar_tests.rs
@@ -95,6 +95,34 @@ fn has_thread_entry(sidebar: &Sidebar, session_id: &acp::SessionId) -> bool {
         .any(|entry| matches!(entry, ListEntry::Thread(t) if t.metadata.session_id.as_ref() == Some(session_id)))
 }
 
+#[track_caller]
+fn assert_project_header_has_threads(
+    sidebar: &Entity<Sidebar>,
+    project_name: &str,
+    expected_has_threads: bool,
+    cx: &mut gpui::VisualTestContext,
+) {
+    sidebar.read_with(cx, |sidebar, _cx| {
+        let has_threads = sidebar.contents.entries.iter().find_map(|entry| {
+            if let ListEntry::ProjectHeader {
+                label, has_threads, ..
+            } = entry
+                && label.as_ref() == project_name
+            {
+                Some(*has_threads)
+            } else {
+                None
+            }
+        });
+
+        assert_eq!(
+            has_threads,
+            Some(expected_has_threads),
+            "expected project header `{project_name}` to have has_threads={expected_has_threads}, got {has_threads:?}"
+        );
+    });
+}
+
 #[track_caller]
 fn assert_remote_project_integration_sidebar_state(
     sidebar: &mut Sidebar,
@@ -1540,6 +1568,70 @@ async fn test_agent_panel_terminals_appear_in_sidebar_and_search(cx: &mut TestAp
     );
 }
 
+#[gpui::test]
+async fn test_closing_last_agent_panel_terminal_restores_empty_header(cx: &mut TestAppContext) {
+    let project = init_test_project_with_agent_panel("/my-project", cx).await;
+    let (multi_workspace, cx) =
+        cx.add_window_view(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
+    let (sidebar, panel) = setup_sidebar_with_agent_panel(&multi_workspace, cx);
+
+    assert_project_header_has_threads(&sidebar, "my-project", false, cx);
+
+    let terminal_id = panel
+        .update_in(cx, |panel, window, cx| {
+            panel.insert_test_terminal("Dev Server", true, window, cx)
+        })
+        .expect("test terminal should be inserted");
+    cx.run_until_parked();
+
+    assert_project_header_has_threads(&sidebar, "my-project", true, cx);
+
+    let (terminal_metadata, terminal_workspace) = sidebar.read_with(cx, |sidebar, _cx| {
+        sidebar
+            .contents
+            .entries
+            .iter()
+            .find_map(|entry| match entry {
+                ListEntry::Terminal(terminal) if terminal.metadata.terminal_id == terminal_id => {
+                    Some((terminal.metadata.clone(), terminal.workspace.clone()))
+                }
+                _ => None,
+            })
+            .expect("terminal should be visible in sidebar")
+    });
+    sidebar.update_in(cx, |sidebar, window, cx| {
+        sidebar.close_terminal(&terminal_metadata, &terminal_workspace, window, cx);
+    });
+    cx.run_until_parked();
+
+    panel.read_with(cx, |panel, cx| {
+        assert!(!panel.has_terminal(terminal_id));
+        assert!(
+            panel.active_view_is_new_draft(cx),
+            "closing the active terminal should leave the panel on a hidden empty draft"
+        );
+    });
+    assert_eq!(
+        visible_entries_as_strings(&sidebar, cx),
+        vec!["v [my-project]"]
+    );
+    assert_project_header_has_threads(&sidebar, "my-project", false, cx);
+
+    let project_group_key = multi_workspace.read_with(cx, |multi_workspace, cx| {
+        multi_workspace.workspace().read(cx).project_group_key(cx)
+    });
+    sidebar.update_in(cx, |sidebar, window, cx| {
+        sidebar.toggle_collapse(&project_group_key, window, cx);
+    });
+    cx.run_until_parked();
+
+    assert_eq!(
+        visible_entries_as_strings(&sidebar, cx),
+        vec!["> [my-project]"]
+    );
+    assert_project_header_has_threads(&sidebar, "my-project", false, cx);
+}
+
 #[gpui::test]
 async fn test_agent_panel_terminal_metadata_remains_visible_after_panel_is_removed(
     cx: &mut TestAppContext,

From ae47ec9ac088483119b286bbc3e27c95afd88d27 Mon Sep 17 00:00:00 2001
From: Daniel Strobusch <1847260+dastrobu@users.noreply.github.com>
Date: Tue, 19 May 2026 17:56:34 +0200
Subject: [PATCH 030/105] language_models: Fix Gemini tool parameter
 nullability and multi-type schema (#49292)

Transform JSON schemas for Google AI tools to use `nullable: true`
instead of `type: ["type", "null"]`, which is not supported by the
Gemini API.

Additionally, convert multi-type arrays (e.g., `type: ["string",
"number"]`)
to `anyOf` constraints, as Gemini expects a single string for the `type`
field.

This handles recursive transformation of properties, items, definitions,
and logical operators, safely merging conflicting `anyOf` and `allOf`
constraints.

Closes https://github.com/zed-industries/zed/issues/44875
Closes https://github.com/zed-industries/zed/issues/32429

Release Notes:

- Fixed a bug where using Gemini with certain tools (especially via MCP)
resulted in "Invalid JSON payload received" errors due to incompatible
JSON schema formats.

## Testing

Added unit tests in `crates/language_model/src/tool_schema.rs` covering
nullability, multi-types, and `oneOf` conversions.

### Manual Testing with MCP Test Server
The [MCP Test Server](https://github.com/dastrobu/mcp-test-server) was
used to verify these edge cases with Gemini 3 Flash.

#### Setup
1. Install the test server: `cargo install --git
https://github.com/dastrobu/mcp-test-server`
2. Add to Zed `settings.json`:
   ```json
   "context_servers": [
     {
       "command": "mcp-test-server"
     }
   ]
   ```


Use the following pattern in a chat window:

```
call the add_tool function to create a new tool: weather with input schema:

  {
    "type": "object",
    "properties": {
      "city": { "type": ["string", "null"] }
    }
  }
```
Afterwards:
...

```
call it
```

Without fix:

<img width="671" height="448" alt="image"
src="https://github.com/user-attachments/assets/e8b6e7bd-d431-4a7e-8c9a-fff73d82127d"
/>

With fix:

<img width="729" height="334" alt="image"
src="https://github.com/user-attachments/assets/eb758765-4c34-4915-a8cf-dd4bfb993619"
/>

#### Cases verified manually:



**1. Nullability in properties**
- **Input:**
  ```json
  {
    "type": "object",
    "properties": {
      "city": { "type": ["string", "null"] }
    }
  }
  ```
- **Converted:**
  ```json
  {
    "type": "object",
    "properties": {
      "city": { "type": "string", "nullable": true }
    }
  }
  ```

**2. Multi-type properties**
- **Input:**
  ```json
  {
    "type": "object",
    "properties": {
      "city": { "type": ["string", "number"] }
    }
  }
  ```
- **Converted:**
  ```json
  {
    "type": "object",
    "properties": {
      "city": {
        "anyOf": [
          { "type": "string" },
          { "type": "number" }
        ]
      }
    }
  }
  ```

**3. Explicit `anyOf` with nullability**
- **Input:**
  ```json
  {
    "type": "object",
    "properties": {
      "city": {
        "anyOf": [
          { "type": "string" },
          { "type": "null" }
        ]
      }
    }
  }
  ```
- **Converted:**
  ```json
  {
    "type": "object",
    "properties": {
      "city": {
        "anyOf": [
          { "type": "string" },
          { "nullable": true }
        ]
      }
    }
  }
  ```

**4. Conflicting `anyOf` sources (Multi-type + existing `anyOf`)**
- **Input:**
  ```json
  {
    "type": "object",
    "properties": {
      "city": {
        "type": ["string", "number"],
        "anyOf": [
          { "minLength": 5 }
        ]
      }
    }
  }
  ```
- **Converted:**
  ```json
  {
    "type": "object",
    "properties": {
      "city": {
        "allOf": [
          { "anyOf": [{ "minLength": 5 }] },
          { "anyOf": [{ "type": "string" }, { "type": "number" }] }
        ]
      }
    }
  }
  ```

Co-authored-by: Richard Feldman <richard@zed.dev>
---
 Cargo.lock                                    |   1 +
 crates/language_model_core/Cargo.toml         |   1 +
 crates/language_model_core/src/tool_schema.rs | 357 +++++++++++++++++-
 3 files changed, 351 insertions(+), 8 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f976aefdf3d..c9f821f7f17 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9651,6 +9651,7 @@ dependencies = [
  "futures 0.3.32",
  "gpui_shared_string",
  "http_client",
+ "log",
  "partial-json-fixer",
  "schemars 1.0.4",
  "serde",
diff --git a/crates/language_model_core/Cargo.toml b/crates/language_model_core/Cargo.toml
index e9aa06400b6..c254989b4d5 100644
--- a/crates/language_model_core/Cargo.toml
+++ b/crates/language_model_core/Cargo.toml
@@ -19,6 +19,7 @@ cloud_llm_client.workspace = true
 futures.workspace = true
 gpui_shared_string.workspace = true
 http_client.workspace = true
+log.workspace = true
 partial-json-fixer.workspace = true
 schemars.workspace = true
 serde.workspace = true
diff --git a/crates/language_model_core/src/tool_schema.rs b/crates/language_model_core/src/tool_schema.rs
index 86e6d6d137e..729d625939c 100644
--- a/crates/language_model_core/src/tool_schema.rs
+++ b/crates/language_model_core/src/tool_schema.rs
@@ -4,7 +4,7 @@ use schemars::{
     generate::SchemaSettings,
     transform::{Transform, transform_subschemas},
 };
-use serde_json::Value;
+use serde_json::{Map, Value, json};
 
 /// Indicates the format used to define the input schema for a language model tool.
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
@@ -64,6 +64,8 @@ pub fn adapt_schema_to_format(
     json: &mut Value,
     format: LanguageModelToolSchemaFormat,
 ) -> Result<()> {
+    log::trace!("Adapting schema to format {:?}: {}", format, json);
+
     if let Value::Object(obj) = json {
         obj.remove("$schema");
         obj.remove("title");
@@ -73,7 +75,10 @@ pub fn adapt_schema_to_format(
     match format {
         LanguageModelToolSchemaFormat::JsonSchema => preprocess_json_schema(json),
         LanguageModelToolSchemaFormat::JsonSchemaSubset => adapt_to_json_schema_subset(json),
-    }
+    }?;
+
+    log::trace!("Adapted schema: {}", json);
+    Ok(())
 }
 
 fn preprocess_json_schema(json: &mut Value) -> Result<()> {
@@ -118,6 +123,9 @@ fn adapt_to_json_schema_subset(json: &mut Value) -> Result<()> {
             }
         }
 
+        convert_null_in_types_to_nullable(obj);
+        convert_types_to_any_of_defs(obj);
+
         // Ensure that the type field is not an array. This can happen with MCP tool
         // schemas that use multiple types (e.g. `["string", "number"]` or `["string", "null"]`).
         if let Some(type_value) = obj.get_mut("type")
@@ -126,7 +134,6 @@ fn adapt_to_json_schema_subset(json: &mut Value) -> Result<()> {
         {
             *type_value = first_type;
         }
-
         if matches!(obj.get("description"), Some(Value::String(_)))
             && !obj.contains_key("type")
             && !(obj.contains_key("anyOf")
@@ -141,7 +148,7 @@ fn adapt_to_json_schema_subset(json: &mut Value) -> Result<()> {
         {
             let subschemas_clone = subschemas.clone();
             obj.remove("oneOf");
-            obj.insert("anyOf".to_string(), subschemas_clone);
+            push_any_of_constraint(obj, subschemas_clone);
         }
 
         for (_, value) in obj.iter_mut() {
@@ -157,11 +164,278 @@ fn adapt_to_json_schema_subset(json: &mut Value) -> Result<()> {
     Ok(())
 }
 
+fn convert_null_in_types_to_nullable(obj: &mut Map<String, Value>) {
+    let mut nullable_found_in_type = false;
+
+    if let Some(type_entry) = obj.get_mut("type") {
+        if let Some(types) = type_entry.as_array_mut() {
+            let mut had_null_type = false;
+            types.retain(|t| {
+                if t.as_str() == Some("null") {
+                    had_null_type = true;
+                    false
+                } else {
+                    true
+                }
+            });
+
+            if had_null_type {
+                nullable_found_in_type = true;
+                if types.len() == 1 {
+                    *type_entry = types.remove(0);
+                } else if types.is_empty() {
+                    obj.remove("type");
+                }
+            }
+        } else if let Some(type_str) = type_entry.as_str() {
+            if type_str == "null" {
+                nullable_found_in_type = true;
+                obj.remove("type");
+            }
+        }
+    }
+    if nullable_found_in_type {
+        obj.insert("nullable".to_string(), Value::Bool(true));
+    }
+}
+
+fn convert_types_to_any_of_defs(obj: &mut Map<String, Value>) {
+    if let Some(type_entry) = obj.get_mut("type") {
+        if let Some(types) = type_entry.as_array_mut() {
+            if types.len() > 1 {
+                let remaining_types = std::mem::take(types);
+                let mut any_of_schemas = Vec::new();
+                for t in remaining_types {
+                    any_of_schemas.push(json!({"type": t}));
+                }
+                obj.remove("type");
+                push_any_of_constraint(obj, Value::Array(any_of_schemas));
+            }
+        }
+    }
+}
+
+fn push_any_of_constraint(obj: &mut Map<String, Value>, any_of_schemas: Value) {
+    if let Some(existing_any_of) = obj.remove("anyOf") {
+        let mut all_of = obj
+            .remove("allOf")
+            .and_then(|v| v.as_array().cloned())
+            .unwrap_or_default();
+        if all_of.is_empty() {
+            all_of.push(json!({"anyOf": existing_any_of}));
+        }
+        all_of.push(json!({"anyOf": any_of_schemas}));
+        obj.insert("allOf".to_string(), Value::Array(all_of));
+    } else if let Some(all_of) = obj.get_mut("allOf").and_then(|v| v.as_array_mut()) {
+        all_of.push(json!({"anyOf": any_of_schemas}));
+    } else {
+        obj.insert("anyOf".to_string(), any_of_schemas);
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
     use serde_json::json;
 
+    #[test]
+    fn test_convert_null_in_types_to_nullable() {
+        // ["string", "null"] -> "string", nullable: true
+        let mut obj = json!({"type": ["string", "null"]})
+            .as_object_mut()
+            .unwrap()
+            .to_owned();
+        convert_null_in_types_to_nullable(&mut obj);
+        assert_eq!(
+            obj,
+            json!({"type": "string", "nullable": true})
+                .as_object()
+                .unwrap()
+                .to_owned()
+        );
+
+        // "null" -> nullable: true
+        let mut obj = json!({"type": "null"}).as_object_mut().unwrap().to_owned();
+        convert_null_in_types_to_nullable(&mut obj);
+        assert_eq!(
+            obj,
+            json!({"nullable": true}).as_object().unwrap().to_owned()
+        );
+
+        // ["string", "number", "null"] -> ["string", "number"], nullable: true (anyOf handled elsewhere)
+        let mut obj = json!({"type": ["string", "number", "null"]})
+            .as_object_mut()
+            .unwrap()
+            .to_owned();
+        convert_null_in_types_to_nullable(&mut obj);
+        assert_eq!(
+            obj,
+            json!({"type": ["string", "number"], "nullable": true})
+                .as_object()
+                .unwrap()
+                .to_owned()
+        );
+
+        // "string" (no change, not nullable)
+        let mut obj = json!({"type": "string"})
+            .as_object_mut()
+            .unwrap()
+            .to_owned();
+        convert_null_in_types_to_nullable(&mut obj);
+        assert_eq!(
+            obj,
+            json!({"type": "string"}).as_object().unwrap().to_owned()
+        );
+
+        // ["string", "number"] (no change, not nullable)
+        let mut obj = json!({"type": ["string", "number"]})
+            .as_object_mut()
+            .unwrap()
+            .to_owned();
+        convert_null_in_types_to_nullable(&mut obj);
+        assert_eq!(
+            obj,
+            json!({"type": ["string", "number"]})
+                .as_object()
+                .unwrap()
+                .to_owned()
+        );
+
+        // object with other properties, ["boolean", "null"]
+        let mut obj = json!({
+            "description": "A test field",
+            "type": ["boolean", "null"]
+        })
+        .as_object_mut()
+        .unwrap()
+        .to_owned();
+        convert_null_in_types_to_nullable(&mut obj);
+        assert_eq!(
+            obj,
+            json!({
+                "description": "A test field",
+                "type": "boolean",
+                "nullable": true
+            })
+            .as_object()
+            .unwrap()
+            .to_owned()
+        );
+    }
+
+    #[test]
+    fn test_convert_types_to_any_of_defs() {
+        // ["string", "number"] -> anyOf with string and number
+        let mut obj = json!({"type": ["string", "number"]})
+            .as_object_mut()
+            .unwrap()
+            .to_owned();
+        convert_types_to_any_of_defs(&mut obj);
+        assert_eq!(
+            obj,
+            json!({
+                "anyOf": [
+                    {"type": "string"},
+                    {"type": "number"}
+                ]
+            })
+            .as_object()
+            .unwrap()
+            .to_owned()
+        );
+
+        // "string" (no change)
+        let mut obj = json!({"type": "string"})
+            .as_object_mut()
+            .unwrap()
+            .to_owned();
+        convert_types_to_any_of_defs(&mut obj);
+        assert_eq!(
+            obj,
+            json!({"type": "string"}).as_object().unwrap().to_owned()
+        );
+
+        // object with other properties, ["string", "number"]
+        let mut obj = json!({
+            "description": "A test field",
+            "type": ["string", "number"]
+        })
+        .as_object_mut()
+        .unwrap()
+        .to_owned();
+        convert_types_to_any_of_defs(&mut obj);
+        assert_eq!(
+            obj,
+            json!({
+                "description": "A test field",
+                "anyOf": [
+                    {"type": "string"},
+                    {"type": "number"}
+                ]
+            })
+            .as_object()
+            .unwrap()
+            .to_owned()
+        );
+
+        // anyOf already present (no change)
+        let mut obj = json!({
+            "anyOf": [
+                {"type": "string"},
+                {"type": "number"}
+            ]
+        })
+        .as_object_mut()
+        .unwrap()
+        .to_owned();
+        convert_types_to_any_of_defs(&mut obj);
+        assert_eq!(
+            obj,
+            json!({
+                "anyOf": [
+                    {"type": "string"},
+                    {"type": "number"}
+                ]
+            })
+            .as_object()
+            .unwrap()
+            .to_owned()
+        );
+
+        // both type array and anyOf present
+        let mut obj = json!({
+            "type": ["string", "number"],
+            "anyOf": [
+                {"format": "email"}
+            ]
+        })
+        .as_object_mut()
+        .unwrap()
+        .to_owned();
+        convert_types_to_any_of_defs(&mut obj);
+        assert_eq!(
+            obj,
+            json!({
+                "allOf": [
+                    {
+                        "anyOf": [
+                            {"format": "email"}
+                        ]
+                    },
+                    {
+                        "anyOf": [
+                            {"type": "string"},
+                            {"type": "number"}
+                        ]
+                    }
+                ]
+            })
+            .as_object()
+            .unwrap()
+            .to_owned()
+        );
+    }
+
     #[test]
     fn test_transform_adds_type_when_missing() {
         let mut json = json!({
@@ -259,6 +533,69 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_transform_null_in_any_of() {
+        let mut json = json!({
+            "anyOf": [
+                { "type": "string" },
+                { "type": "null" }
+            ]
+        });
+
+        adapt_to_json_schema_subset(&mut json).unwrap();
+
+        assert_eq!(
+            json,
+            json!({
+                "anyOf": [
+                    { "type": "string" },
+                    { "nullable": true }
+                ]
+            })
+        );
+    }
+
+    #[test]
+    fn test_transform_conflicting_any_of_sources() {
+        let mut json = json!({
+            "type": ["string", "number"],
+            "anyOf": [
+                { "minLength": 5 }
+            ],
+            "oneOf": [
+                { "pattern": "^a" },
+                { "pattern": "^b" }
+            ]
+        });
+
+        adapt_to_json_schema_subset(&mut json).unwrap();
+
+        assert_eq!(
+            json,
+            json!({
+                "allOf": [
+                    {
+                        "anyOf": [
+                            { "minLength": 5 },
+                        ]
+                    },
+                    {
+                        "anyOf": [
+                            {"type": "string"},
+                            {"type": "number"}
+                        ]
+                    },
+                    {
+                        "anyOf": [
+                            { "pattern": "^a" },
+                            { "pattern": "^b" }
+                        ]
+                    }
+                ]
+            })
+        );
+    }
+
     #[test]
     fn test_transform_one_of_to_any_of() {
         let mut json = json!({
@@ -308,8 +645,8 @@ mod tests {
                     "nested": {
                         "anyOf": [
                             { "type": "string" },
-                            { "type": "null" }
-                        ]
+                            { "nullable": true }
+                        ],
                     }
                 }
             })
@@ -340,12 +677,16 @@ mod tests {
                 "type": "object",
                 "properties": {
                     "projectSlugOrId": {
-                        "type": "string",
+                        "anyOf": [
+                            {"type": "string"},
+                            {"type": "number"}
+                        ],
                         "description": "Project slug or numeric ID"
                     },
                     "optionalName": {
                         "type": "string",
-                        "description": "An optional name"
+                        "description": "An optional name",
+                        "nullable": true
                     }
                 }
             })

From a949cabb327ddab4427ad753b172c6653845711f Mon Sep 17 00:00:00 2001
From: Oleksiy Syvokon <oleksiy@zed.dev>
Date: Tue, 19 May 2026 20:04:29 +0300
Subject: [PATCH 031/105] Fix crash in manipulate_text on multibuffers (#57165)

In `Editor::manipulate_text`, we computed selection boundaries for the
updated text assuming the requested edit would be applied exactly. This
is not always true. As a result, we could produce an invalid selection
range and panic.

This change replaces manual selection boundary computation with anchors.
It also skips edits when `new_text == old_text`.

Closes FR-10.

Release Notes:

- N/A
---
 crates/editor/src/editor.rs       | 20 +++++------
 crates/editor/src/editor_tests.rs | 55 +++++++++++++++++++++++++++++++
 2 files changed, 65 insertions(+), 10 deletions(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 1b1345d4a28..1a470ebeb12 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -6771,7 +6771,6 @@ impl Editor {
 
         let mut new_selections = Vec::new();
         let mut edits = Vec::new();
-        let mut selection_adjustment = 0isize;
 
         for selection in self.selections.all_adjusted(&self.display_snapshot(cx)) {
             let selection_is_empty = selection.is_empty();
@@ -6786,23 +6785,24 @@ impl Editor {
                 )
             };
 
-            let text = buffer.text_for_range(start..end).collect::<String>();
-            let old_length = text.len() as isize;
-            let text = callback(&text);
+            let old_text = buffer.text_for_range(start..end).collect::<String>();
+            let new_text = callback(&old_text);
 
             new_selections.push(Selection {
-                start: MultiBufferOffset((start.0 as isize - selection_adjustment) as usize),
-                end: MultiBufferOffset(
-                    ((start.0 + text.len()) as isize - selection_adjustment) as usize,
-                ),
+                start: buffer.anchor_before(start),
+                end: buffer.anchor_after(end),
                 goal: SelectionGoal::None,
                 id: selection.id,
                 reversed: selection.reversed,
             });
 
-            selection_adjustment += old_length - text.len() as isize;
+            if new_text != old_text {
+                edits.push((start..end, new_text));
+            }
+        }
 
-            edits.push((start..end, text));
+        if edits.is_empty() {
+            return;
         }
 
         self.transact(window, cx, |this, window, cx| {
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index 61410ee677c..257122307e6 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -6898,6 +6898,61 @@ async fn test_convert_to_base64(cx: &mut TestAppContext) {
     "});
 }
 
+#[gpui::test]
+fn test_manipulate_text_handles_cross_excerpt_edit_that_applies_differently(
+    cx: &mut TestAppContext,
+) {
+    init_test(cx, |_| {});
+
+    let buffer_1 = cx.new(|cx| {
+        let mut buffer = Buffer::local("ab", cx);
+        // The selected multibuffer range starts in this excerpt, but edits to
+        // it are skipped because the underlying buffer is read-only.
+        buffer.set_capability(language::Capability::ReadOnly, cx);
+        buffer
+    });
+    let buffer_2 = cx.new(|cx| Buffer::local("cd", cx));
+    let multibuffer = cx.new(|cx| {
+        let mut multibuffer = MultiBuffer::new(ReadWrite);
+        multibuffer.set_excerpts_for_path(
+            PathKey::sorted(0),
+            buffer_1.clone(),
+            [Point::new(0, 0)..Point::new(0, 2)],
+            0,
+            cx,
+        );
+        multibuffer.set_excerpts_for_path(
+            PathKey::sorted(1),
+            buffer_2.clone(),
+            [Point::new(0, 0)..Point::new(0, 2)],
+            0,
+            cx,
+        );
+        multibuffer
+    });
+
+    cx.add_window(|window, cx| {
+        let mut editor = build_editor(multibuffer, window, cx);
+        let len = editor.buffer().read(cx).len(cx);
+        editor.change_selections(SelectionEffects::no_scroll(), window, cx, |selections| {
+            selections.select_ranges([MultiBufferOffset(0)..len])
+        });
+
+        // No-op transformations should not be sent through `MultiBuffer::edit`.
+        editor.manipulate_text(window, cx, |text| text.to_string());
+        assert_eq!(buffer_1.read(cx).text(), "ab");
+        assert_eq!(buffer_2.read(cx).text(), "cd");
+
+        // A real replacement can apply differently than requested; selection
+        // remapping should follow the actual edit instead of predicted offsets.
+        editor.manipulate_text(window, cx, |_| "replacement".to_string());
+        assert_eq!(buffer_1.read(cx).text(), "ab");
+        assert_eq!(buffer_2.read(cx).text(), "");
+
+        editor
+    });
+}
+
 #[gpui::test]
 async fn test_manipulate_text(cx: &mut TestAppContext) {
     init_test(cx, |_| {});

From c0596fade73036c6d2ab6f8a7caeac6722739e65 Mon Sep 17 00:00:00 2001
From: alkinun <alkinunl@gmail.com>
Date: Tue, 19 May 2026 20:20:24 +0300
Subject: [PATCH 032/105] markdown: Fix escaping non-ASCII chars (#55782)

Fixes #55704

The `escape` function in `crates/markdown/src/markdown.rs` was calling
`c as u8` on the `char`s before passing to `MarkdownEscaper::next()`.
This strips non ASCII Unicode codepoints down to just their low 8 bits
which might be in the ASCII punctuation range and thus cause an extra
backslash to be added in front of these non ASCII chars.

Release Notes:

- Fixed a bug where non-ASCII chars in diagnostic messages were
incorrectly rendered with spurious `\` characters
---
 crates/markdown/src/markdown.rs | 52 +++++++++++++++++++++++----------
 1 file changed, 37 insertions(+), 15 deletions(-)

diff --git a/crates/markdown/src/markdown.rs b/crates/markdown/src/markdown.rs
index 69feee416da..44e87f55677 100644
--- a/crates/markdown/src/markdown.rs
+++ b/crates/markdown/src/markdown.rs
@@ -401,12 +401,12 @@ enum EscapeAction {
 }
 
 impl EscapeAction {
-    fn output_len(&self) -> usize {
+    fn output_len(&self, c: char) -> usize {
         match self {
-            Self::PassThrough => 1,
+            Self::PassThrough => c.len_utf8(),
             Self::Nbsp(count) => count * '\u{00A0}'.len_utf8(),
             Self::DoubleNewline => 2,
-            Self::PrefixBackslash => 2,
+            Self::PrefixBackslash => '\\'.len_utf8() + c.len_utf8(),
         }
     }
 
@@ -431,8 +431,6 @@ impl EscapeAction {
     }
 }
 
-// Valid to operate on raw bytes since multi-byte UTF-8
-// sequences never contain ASCII-range bytes.
 struct MarkdownEscaper {
     in_leading_whitespace: bool,
 }
@@ -446,21 +444,21 @@ impl MarkdownEscaper {
         }
     }
 
-    fn next(&mut self, byte: u8) -> EscapeAction {
-        let action = if self.in_leading_whitespace && byte == b'\t' {
+    fn next(&mut self, c: char) -> EscapeAction {
+        let action = if self.in_leading_whitespace && c == '\t' {
             EscapeAction::Nbsp(Self::TAB_SIZE)
-        } else if self.in_leading_whitespace && byte == b' ' {
+        } else if self.in_leading_whitespace && c == ' ' {
             EscapeAction::Nbsp(1)
-        } else if byte == b'\n' {
+        } else if c == '\n' {
             EscapeAction::DoubleNewline
-        } else if byte.is_ascii_punctuation() {
+        } else if c.is_ascii_punctuation() {
             EscapeAction::PrefixBackslash
         } else {
             EscapeAction::PassThrough
         };
 
         self.in_leading_whitespace =
-            byte == b'\n' || (self.in_leading_whitespace && (byte == b' ' || byte == b'\t'));
+            c == '\n' || (self.in_leading_whitespace && (c == ' ' || c == '\t'));
         action
     }
 }
@@ -675,7 +673,7 @@ impl Markdown {
     pub fn escape(s: &str) -> Cow<'_, str> {
         let output_len: usize = {
             let mut escaper = MarkdownEscaper::new();
-            s.bytes().map(|byte| escaper.next(byte).output_len()).sum()
+            s.chars().map(|c| escaper.next(c).output_len(c)).sum()
         };
 
         if output_len == s.len() {
@@ -685,7 +683,7 @@ impl Markdown {
         let mut escaper = MarkdownEscaper::new();
         let mut output = String::with_capacity(output_len);
         for c in s.chars() {
-            escaper.next(c as u8).write_to(c, &mut output);
+            escaper.next(c).write_to(c, &mut output);
         }
         output.into()
     }
@@ -3931,6 +3929,30 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_escape_non_ascii() {
+        // Cyrillic characters should not have backslashes added before them,
+        // but ASCII punctuation should still be escaped.
+        assert_eq!(Markdown::escape("Привет, мир"), r"Привет\, мир");
+        // Test with markdown special characters mixed in
+        assert_eq!(Markdown::escape("Привет, *мир*"), r"Привет\, \*мир\*");
+        // Test with the exact example from the issue (single quotes are also ASCII punctuation)
+        assert_eq!(
+            Markdown::escape("Отсутствует пробел справа от ','"),
+            r"Отсутствует пробел справа от \'\,\'"
+        );
+        // Test more non-ASCII scripts
+        assert_eq!(
+            Markdown::escape("こんにちは *world*"),
+            r"こんにちは \*world\*"
+        );
+        assert_eq!(Markdown::escape("العربيّة [link]"), r"العربيّة \[link\]");
+        assert_eq!(Markdown::escape("Ελληνικά _text_"), r"Ελληνικά \_text\_");
+        assert_eq!(Markdown::escape("עברית `code`"), r"עברית \`code\`");
+        // Non-ASCII followed by ASCII punctuation
+        assert_eq!(Markdown::escape("Test: тест"), r"Test\: тест");
+    }
+
     fn has_code_block(markdown: &str) -> bool {
         let parsed_data = parse_markdown_with_options(markdown, false, false);
         parsed_data
@@ -3959,12 +3981,12 @@ mod tests {
         ];
         for input in cases {
             let mut escaper = MarkdownEscaper::new();
-            let precomputed: usize = input.bytes().map(|b| escaper.next(b).output_len()).sum();
+            let precomputed: usize = input.chars().map(|c| escaper.next(c).output_len(c)).sum();
 
             let mut escaper = MarkdownEscaper::new();
             let mut output = String::new();
             for c in input.chars() {
-                escaper.next(c as u8).write_to(c, &mut output);
+                escaper.next(c).write_to(c, &mut output);
             }
 
             assert_eq!(precomputed, output.len(), "length mismatch for {:?}", input);

From 0d832bc6d5498f545c5f05ba1f1fc84285434eb6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=20Houl=C3=A9?=
 <13155277+tomhoule@users.noreply.github.com>
Date: Tue, 19 May 2026 19:45:07 +0200
Subject: [PATCH 033/105] Implement MCP OAuth client preregistration (#52900)

In the interactive MCP OAuth flow, the MCP client registers itself with
the authorization in one of three ways:

- Client ID Metadata Document aka CIMD (recommended default). This is
already implemented: https://zed.dev/oauth/client-metadata.json.
- Dynamic Client Registration (DCR). This is the traditional method.
Also already implemented in Zed.
- Pre-registration: the client is registered out of band, typically in
the IdP or SaaS provider's UI. You get a client id and maybe a client
secret, that have to be provided by the MCP client when it wants to
exchange an access token. This is what this pull request is about.

This PR has two main parts:

- Allow users to configure a client id and optional client secret for an
MCP server in their configuration, under a new `oauth` key, and take it
into account
- Make the MCP server state and the configuration modal aware of the
intermediate states (client secret missing) and error cases stemming
from client pre-registration.

The client secret can be stored either in the system keychain or in
plain text in the MCP server configuration. The UI tries to steer user
towards the more secure option: the keychain.

<img width="715" height="201" alt="Screenshot 2026-04-10 at 16 48 06"
src="https://github.com/user-attachments/assets/5e64103e-6746-4ef0-8bd9-533d492b6912"
/>

<img width="884" height="544" alt="Screenshot 2026-04-10 at 16 47 07"
src="https://github.com/user-attachments/assets/0e35bb3c-cbc4-4e8c-a713-66323597b2e2"
/>


<img width="785" height="558" alt="Screenshot 2026-04-10 at 16 47 23"
src="https://github.com/user-attachments/assets/03339187-1508-461a-87ae-a7c2647df9a5"
/>



Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Closes
https://github.com/issues/assigned?issue=zed-industries%7Czed%7C52198

**Note for the reviewer: I know how busy the AI team is at the moment so
please treat this as low priority, we don't have signal that this is a
highly desired feature. It's a rather large PR, so I'm happy to pair
review / walk through it.**

Release Notes:

- Added support for OAuth client pre-registration (client id, client
secret) to the built-in MCP client.
---
 .../src/tools/context_server_registry.rs      |   3 +-
 crates/agent_servers/src/acp.rs               |   1 +
 crates/agent_ui/src/agent_configuration.rs    |  51 ++-
 .../configure_context_server_modal.rs         | 368 ++++++++++++++++--
 crates/context_server/src/oauth.rs            | 101 +++--
 crates/project/src/context_server_store.rs    | 284 +++++++++++++-
 crates/project/src/project_settings.rs        |  28 ++
 .../tests/integration/context_server_store.rs |   4 +
 crates/settings_content/src/project.rs        |  18 +
 .../ui/src/components/ai/ai_setting_item.rs   |   4 +-
 10 files changed, 797 insertions(+), 65 deletions(-)

diff --git a/crates/agent/src/tools/context_server_registry.rs b/crates/agent/src/tools/context_server_registry.rs
index 6c0e8d31557..d9dc972e24f 100644
--- a/crates/agent/src/tools/context_server_registry.rs
+++ b/crates/agent/src/tools/context_server_registry.rs
@@ -261,7 +261,8 @@ impl ContextServerRegistry {
             }
             ContextServerStatus::Stopped
             | ContextServerStatus::Error(_)
-            | ContextServerStatus::AuthRequired => {
+            | ContextServerStatus::AuthRequired
+            | ContextServerStatus::ClientSecretRequired { .. } => {
                 if let Some(registered_server) = self.registered_servers.remove(server_id) {
                     if !registered_server.tools.is_empty() {
                         cx.emit(ContextServerRegistryEvent::ToolsChanged);
diff --git a/crates/agent_servers/src/acp.rs b/crates/agent_servers/src/acp.rs
index ff5519b7240..3a718c7a9e8 100644
--- a/crates/agent_servers/src/acp.rs
+++ b/crates/agent_servers/src/acp.rs
@@ -3844,6 +3844,7 @@ fn mcp_servers_for_project(project: &Entity<Project>, cx: &App) -> Vec<acp::McpS
                     url,
                     headers,
                     timeout: _,
+                    oauth: _,
                 } => Some(acp::McpServer::Http(
                     acp::McpServerHttp::new(id.0.to_string(), url.to_string()).headers(
                         headers
diff --git a/crates/agent_ui/src/agent_configuration.rs b/crates/agent_ui/src/agent_configuration.rs
index 67d21211026..eb6ea3e81fc 100644
--- a/crates/agent_ui/src/agent_configuration.rs
+++ b/crates/agent_ui/src/agent_configuration.rs
@@ -664,8 +664,14 @@ impl AgentConfiguration {
             None
         };
         let auth_required = matches!(server_status, ContextServerStatus::AuthRequired);
+        let client_secret_required = matches!(
+            server_status,
+            ContextServerStatus::ClientSecretRequired { .. }
+        );
         let authenticating = matches!(server_status, ContextServerStatus::Authenticating);
         let context_server_store = self.context_server_store.clone();
+        let workspace = self.workspace.clone();
+        let language_registry = self.language_registry.clone();
 
         let tool_count = self
             .context_server_registry
@@ -685,6 +691,9 @@ impl AgentConfiguration {
             ContextServerStatus::Error(_) => AiSettingItemStatus::Error,
             ContextServerStatus::Stopped => AiSettingItemStatus::Stopped,
             ContextServerStatus::AuthRequired => AiSettingItemStatus::AuthRequired,
+            ContextServerStatus::ClientSecretRequired { .. } => {
+                AiSettingItemStatus::ClientSecretRequired
+            }
             ContextServerStatus::Authenticating => AiSettingItemStatus::Authenticating,
         };
 
@@ -886,7 +895,7 @@ impl AgentConfiguration {
                             ),
                     )
                     .child(
-                        Button::new("error-logout-server", "Authenticate")
+                        Button::new("authenticate-server", "Authenticate")
                             .style(ButtonStyle::Outlined)
                             .label_size(LabelSize::Small)
                             .on_click({
@@ -900,6 +909,46 @@ impl AgentConfiguration {
                     )
                     .into_any_element(),
             )
+        } else if client_secret_required {
+            Some(
+                feedback_base_container()
+                    .child(
+                        h_flex()
+                            .pr_4()
+                            .min_w_0()
+                            .w_full()
+                            .gap_2()
+                            .child(
+                                Icon::new(IconName::Info)
+                                    .size(IconSize::XSmall)
+                                    .color(Color::Muted),
+                            )
+                            .child(
+                                Label::new("Enter a client secret to connect this server")
+                                    .color(Color::Muted)
+                                    .size(LabelSize::Small),
+                            ),
+                    )
+                    .child(
+                        Button::new("enter-client-secret", "Enter Client Secret")
+                            .style(ButtonStyle::Outlined)
+                            .label_size(LabelSize::Small)
+                            .on_click({
+                                let context_server_id = context_server_id.clone();
+                                move |_event, window, cx| {
+                                    ConfigureContextServerModal::show_modal_for_existing_server(
+                                        context_server_id.clone(),
+                                        language_registry.clone(),
+                                        workspace.clone(),
+                                        window,
+                                        cx,
+                                    )
+                                    .detach();
+                                }
+                            }),
+                    )
+                    .into_any_element(),
+            )
         } else if authenticating {
             Some(
                 h_flex()
diff --git a/crates/agent_ui/src/agent_configuration/configure_context_server_modal.rs b/crates/agent_ui/src/agent_configuration/configure_context_server_modal.rs
index 48d01e506bf..5ccc901b4a4 100644
--- a/crates/agent_ui/src/agent_configuration/configure_context_server_modal.rs
+++ b/crates/agent_ui/src/agent_configuration/configure_context_server_modal.rs
@@ -17,7 +17,7 @@ use project::{
         ContextServerStatus, ContextServerStore, ServerStatusChangedEvent,
         registry::ContextServerDescriptorRegistry,
     },
-    project_settings::{ContextServerSettings, ProjectSettings},
+    project_settings::{ContextServerSettings, OAuthClientSettings, ProjectSettings},
     worktree_store::WorktreeStore,
 };
 use serde::Deserialize;
@@ -43,7 +43,9 @@ enum ConfigurationTarget {
         id: ContextServerId,
         url: String,
         headers: HashMap<String, String>,
+        oauth: Option<OAuthClientSettings>,
     },
+
     Extension {
         id: ContextServerId,
         repository_url: Option<SharedString>,
@@ -121,15 +123,17 @@ impl ConfigurationSource {
                 id,
                 url,
                 headers: auth,
+                oauth,
             } => ConfigurationSource::Existing {
                 editor: create_editor(
-                    context_server_http_input(Some((id, url, auth))),
+                    context_server_http_input(Some((id, url, auth, oauth))),
                     jsonc_language,
                     window,
                     cx,
                 ),
                 is_http: true,
             },
+
             ConfigurationTarget::Extension {
                 id,
                 repository_url,
@@ -168,7 +172,7 @@ impl ConfigurationSource {
             ConfigurationSource::New { editor, is_http }
             | ConfigurationSource::Existing { editor, is_http } => {
                 if *is_http {
-                    parse_http_input(&editor.read(cx).text(cx)).map(|(id, url, auth)| {
+                    parse_http_input(&editor.read(cx).text(cx)).map(|(id, url, auth, oauth)| {
                         (
                             id,
                             ContextServerSettings::Http {
@@ -176,6 +180,7 @@ impl ConfigurationSource {
                                 url,
                                 headers: auth,
                                 timeout: None,
+                                oauth,
                             },
                         )
                     })
@@ -256,11 +261,16 @@ fn context_server_input(existing: Option<(ContextServerId, ContextServerCommand)
 }
 
 fn context_server_http_input(
-    existing: Option<(ContextServerId, String, HashMap<String, String>)>,
+    existing: Option<(
+        ContextServerId,
+        String,
+        HashMap<String, String>,
+        Option<OAuthClientSettings>,
+    )>,
 ) -> String {
-    let (name, url, headers) = match existing {
-        Some((id, url, headers)) => {
-            let header = if headers.is_empty() {
+    let (name, url, headers, oauth) = match existing {
+        Some((id, url, headers, oauth)) => {
+            let headers = if headers.is_empty() {
                 r#"// "Authorization": "Bearer <token>"#.to_string()
             } else {
                 let json = serde_json::to_string_pretty(&headers).unwrap();
@@ -274,15 +284,48 @@ fn context_server_http_input(
                     .map(|line| format!("  {}", line))
                     .collect::<String>()
             };
-            (id.0.to_string(), url, header)
+            (id.0.to_string(), url, headers, oauth)
         }
         None => (
             "some-remote-server".to_string(),
             "https://example.com/mcp".to_string(),
             r#"// "Authorization": "Bearer <token>"#.to_string(),
+            None,
         ),
     };
 
+    let oauth = oauth.map_or_else(
+        || {
+            r#"
+    /// Uncomment to use a pre-registered OAuth client. You can include the client secret here as well, otherwise it will be prompted interactively and saved in the system keychain.
+    // "oauth": {
+    //   "client_id": "your-client-id",
+    // },"#
+                .to_string()
+        },
+
+        |oauth| {
+            let mut lines = vec![
+                String::from("\n    \"oauth\": {"),
+
+                format!("      \"client_id\": {},", serde_json::to_string(&oauth.client_id).unwrap()),
+            ];
+            if let Some(client_secret) = oauth.client_secret {
+                lines.push(format!(
+                    "      \"client_secret\": {}",
+                    serde_json::to_string(&client_secret).unwrap()
+                ));
+            } else {
+                lines.push(String::from(
+                    "      /// Optional client secret for confidential clients\n      // \"client_secret\": \"your-client-secret\"",
+                ));
+            }
+            lines.push(String::from("    },"));
+
+            lines.join("\n")
+        },
+    );
+
     format!(
         r#"{{
   /// Configure an MCP server that you connect to over HTTP
@@ -290,7 +333,7 @@ fn context_server_http_input(
   /// The name of your remote MCP server
   "{name}": {{
     /// The URL of the remote MCP server
-    "url": "{url}",
+    "url": "{url}",{oauth}
     "headers": {{
      /// Any headers to send along
      {headers}
@@ -300,12 +343,21 @@ fn context_server_http_input(
     )
 }
 
-fn parse_http_input(text: &str) -> Result<(ContextServerId, String, HashMap<String, String>)> {
+fn parse_http_input(
+    text: &str,
+) -> Result<(
+    ContextServerId,
+    String,
+    HashMap<String, String>,
+    Option<OAuthClientSettings>,
+)> {
     #[derive(Deserialize)]
     struct Temp {
         url: String,
         #[serde(default)]
         headers: HashMap<String, String>,
+        #[serde(default)]
+        oauth: Option<OAuthClientSettings>,
     }
     let value: HashMap<String, Temp> = serde_json_lenient::from_str(text)?;
     if value.len() != 1 {
@@ -314,7 +366,12 @@ fn parse_http_input(text: &str) -> Result<(ContextServerId, String, HashMap<Stri
 
     let (key, value) = value.into_iter().next().unwrap();
 
-    Ok((ContextServerId(key.into()), value.url, value.headers))
+    Ok((
+        ContextServerId(key.into()),
+        value.url,
+        value.headers,
+        value.oauth,
+    ))
 }
 
 fn resolve_context_server_extension(
@@ -349,8 +406,16 @@ fn resolve_context_server_extension(
 enum State {
     Idle,
     Waiting,
-    AuthRequired { server_id: ContextServerId },
-    Authenticating { _server_id: ContextServerId },
+    AuthRequired {
+        server_id: ContextServerId,
+    },
+    ClientSecretRequired {
+        server_id: ContextServerId,
+        error: Option<SharedString>,
+    },
+    Authenticating {
+        server_id: ContextServerId,
+    },
     Error(SharedString),
 }
 
@@ -361,10 +426,47 @@ pub struct ConfigureContextServerModal {
     state: State,
     original_server_id: Option<ContextServerId>,
     scroll_handle: ScrollHandle,
+    secret_editor: Entity<Editor>,
     _auth_subscription: Option<Subscription>,
 }
 
 impl ConfigureContextServerModal {
+    fn initial_state(
+        context_server_store: &Entity<ContextServerStore>,
+        target: &ConfigurationTarget,
+        cx: &App,
+    ) -> State {
+        let Some(server_id) = (match target {
+            ConfigurationTarget::Existing { id, .. }
+            | ConfigurationTarget::ExistingHttp { id, .. }
+            | ConfigurationTarget::Extension { id, .. } => Some(id),
+            ConfigurationTarget::New => None,
+        }) else {
+            return State::Idle;
+        };
+
+        match context_server_store.read(cx).status_for_server(server_id) {
+            Some(ContextServerStatus::AuthRequired) => State::AuthRequired {
+                server_id: server_id.clone(),
+            },
+            Some(ContextServerStatus::ClientSecretRequired { error }) => {
+                State::ClientSecretRequired {
+                    server_id: server_id.clone(),
+                    error: error.map(SharedString::from),
+                }
+            }
+            Some(ContextServerStatus::Authenticating) => State::Authenticating {
+                server_id: server_id.clone(),
+            },
+            Some(ContextServerStatus::Error(error)) => State::Error(error.into()),
+
+            Some(ContextServerStatus::Starting)
+            | Some(ContextServerStatus::Running)
+            | Some(ContextServerStatus::Stopped)
+            | None => State::Idle,
+        }
+    }
+
     pub fn register(
         workspace: &mut Workspace,
         language_registry: Arc<LanguageRegistry>,
@@ -426,12 +528,14 @@ impl ConfigureContextServerModal {
                     url,
                     headers,
                     timeout: _,
-                    ..
+                    oauth,
                 } => Some(ConfigurationTarget::ExistingHttp {
                     id: server_id,
                     url,
                     headers,
+                    oauth,
                 }),
+
                 ContextServerSettings::Extension { .. } => {
                     match workspace
                         .update(cx, |workspace, cx| {
@@ -468,9 +572,10 @@ impl ConfigureContextServerModal {
                 let workspace_handle = cx.weak_entity();
                 let context_server_store = workspace.project().read(cx).context_server_store();
                 workspace.toggle_modal(window, cx, |window, cx| Self {
-                    context_server_store,
+                    context_server_store: context_server_store.clone(),
                     workspace: workspace_handle,
-                    state: State::Idle,
+                    state: Self::initial_state(&context_server_store, &target, cx),
+
                     original_server_id: match &target {
                         ConfigurationTarget::Existing { id, .. } => Some(id.clone()),
                         ConfigurationTarget::ExistingHttp { id, .. } => Some(id.clone()),
@@ -485,6 +590,16 @@ impl ConfigureContextServerModal {
                         cx,
                     ),
                     scroll_handle: ScrollHandle::new(),
+                    secret_editor: cx.new(|cx| {
+                        let mut editor = Editor::single_line(window, cx);
+                        editor.set_placeholder_text(
+                            "Enter client secret (leave empty for public clients)",
+                            window,
+                            cx,
+                        );
+                        editor.set_masked(true, cx);
+                        editor
+                    }),
                     _auth_subscription: None,
                 })
             })
@@ -497,13 +612,12 @@ impl ConfigureContextServerModal {
     }
 
     fn confirm(&mut self, _: &menu::Confirm, cx: &mut Context<Self>) {
-        if matches!(
-            self.state,
-            State::Waiting | State::AuthRequired { .. } | State::Authenticating { .. }
-        ) {
+        if matches!(self.state, State::Waiting | State::Authenticating { .. }) {
             return;
         }
 
+        self._auth_subscription = None;
+
         self.state = State::Idle;
         let Some(workspace) = self.workspace.upgrade() else {
             return;
@@ -519,7 +633,7 @@ impl ConfigureContextServerModal {
 
         self.state = State::Waiting;
 
-        let existing_server = self.context_server_store.read(cx).get_running_server(&id);
+        let existing_server = self.context_server_store.read(cx).get_server(&id);
         if existing_server.is_some() {
             self.context_server_store.update(cx, |store, cx| {
                 store.stop_server(&id, cx).log_err();
@@ -542,6 +656,13 @@ impl ConfigureContextServerModal {
                         this.state = State::AuthRequired { server_id: id };
                         cx.notify();
                     }
+                    Ok(ContextServerStatus::ClientSecretRequired { error }) => {
+                        this.state = State::ClientSecretRequired {
+                            server_id: id,
+                            error: error.map(SharedString::from),
+                        };
+                        cx.notify();
+                    }
                     Err(err) => {
                         this.set_error(err, cx);
                     }
@@ -581,13 +702,33 @@ impl ConfigureContextServerModal {
         cx.emit(DismissEvent);
     }
 
+    fn cancel_authentication(&mut self, server_id: &ContextServerId, cx: &mut Context<Self>) {
+        self._auth_subscription = None;
+        self.context_server_store.update(cx, |store, cx| {
+            store.stop_server(server_id, cx).log_err();
+        });
+        self.state = State::Idle;
+        cx.notify();
+    }
+
     fn authenticate(&mut self, server_id: ContextServerId, cx: &mut Context<Self>) {
         self.context_server_store.update(cx, |store, cx| {
             store.authenticate_server(&server_id, cx).log_err();
         });
+        self.await_auth_outcome(server_id, cx);
+    }
 
+    fn submit_client_secret(&mut self, server_id: ContextServerId, cx: &mut Context<Self>) {
+        let secret = self.secret_editor.read(cx).text(cx);
+        self.context_server_store.update(cx, |store, cx| {
+            store.submit_client_secret(&server_id, secret, cx).log_err();
+        });
+        self.await_auth_outcome(server_id, cx);
+    }
+
+    fn await_auth_outcome(&mut self, server_id: ContextServerId, cx: &mut Context<Self>) {
         self.state = State::Authenticating {
-            _server_id: server_id.clone(),
+            server_id: server_id.clone(),
         };
 
         self._auth_subscription = Some(cx.subscribe(
@@ -610,6 +751,14 @@ impl ConfigureContextServerModal {
                         };
                         cx.notify();
                     }
+                    ContextServerStatus::ClientSecretRequired { error } => {
+                        this._auth_subscription = None;
+                        this.state = State::ClientSecretRequired {
+                            server_id: event.server_id.clone(),
+                            error: error.clone().map(SharedString::from),
+                        };
+                        cx.notify();
+                    }
                     ContextServerStatus::Error(error) => {
                         this._auth_subscription = None;
                         this.set_error(error.clone(), cx);
@@ -814,10 +963,7 @@ impl ConfigureContextServerModal {
 
     fn render_modal_footer(&self, cx: &mut Context<Self>) -> ModalFooter {
         let focus_handle = self.focus_handle(cx);
-        let is_busy = matches!(
-            self.state,
-            State::Waiting | State::AuthRequired { .. } | State::Authenticating { .. }
-        );
+        let is_busy = matches!(self.state, State::Waiting | State::Authenticating { .. });
 
         ModalFooter::new()
             .start_slot::<Button>(
@@ -944,6 +1090,112 @@ impl ConfigureContextServerModal {
             )
     }
 
+    fn render_client_secret_required(
+        &self,
+        server_id: &ContextServerId,
+        error: Option<SharedString>,
+        cx: &mut Context<Self>,
+    ) -> Div {
+        let settings = ThemeSettings::get_global(cx);
+        let text_style = TextStyle {
+            color: cx.theme().colors().text,
+            font_family: settings.buffer_font.family.clone(),
+            font_fallbacks: settings.buffer_font.fallbacks.clone(),
+            font_size: settings.buffer_font_size(cx).into(),
+            font_weight: settings.buffer_font.weight,
+            line_height: relative(settings.buffer_line_height.value()),
+            ..Default::default()
+        };
+
+        v_flex()
+            .w_full()
+            .gap_2()
+            .when_some(error, |this, error| {
+                this.child(Self::render_modal_error(error))
+            })
+            .child(
+                h_flex()
+                    .gap_1p5()
+                    .child(
+                        Icon::new(IconName::Info)
+                            .size(IconSize::Small)
+                            .color(Color::Muted),
+                    )
+                    .child(
+                        Label::new(
+                            "Enter your OAuth client secret, or leave empty for public clients",
+                        )
+                        .size(LabelSize::Small)
+                        .color(Color::Muted),
+                    ),
+            )
+            .child(
+                h_flex()
+                    .w_full()
+                    .gap_2()
+                    .capture_action({
+                        let server_id = server_id.clone();
+                        cx.listener(move |this, _: &editor::actions::Newline, _window, cx| {
+                            this.submit_client_secret(server_id.clone(), cx);
+                        })
+                    })
+                    .child(div().flex_1().child(EditorElement::new(
+                        &self.secret_editor,
+                        EditorStyle {
+                            background: cx.theme().colors().editor_background,
+                            local_player: cx.theme().players().local(),
+                            text: text_style,
+                            syntax: cx.theme().syntax().clone(),
+                            ..Default::default()
+                        },
+                    )))
+                    .child(
+                        Button::new("submit-client-secret", "Submit")
+                            .style(ButtonStyle::Outlined)
+                            .label_size(LabelSize::Small)
+                            .on_click({
+                                let server_id = server_id.clone();
+                                cx.listener(move |this, _event, _window, cx| {
+                                    this.submit_client_secret(server_id.clone(), cx);
+                                })
+                            }),
+                    ),
+            )
+    }
+
+    fn render_authenticating(&self, server_id: &ContextServerId, cx: &mut Context<Self>) -> Div {
+        h_flex()
+            .h_8()
+            .gap_2()
+            .justify_center()
+            .child(
+                h_flex()
+                    .gap_1p5()
+                    .child(
+                        Icon::new(IconName::LoadCircle)
+                            .size(IconSize::XSmall)
+                            .color(Color::Muted)
+                            .with_rotate_animation(3),
+                    )
+                    .child(
+                        Label::new("Authenticating…")
+                            .size(LabelSize::Small)
+                            .color(Color::Muted),
+                    ),
+            )
+            .child(
+                Button::new("cancel-authentication", "Cancel")
+                    .style(ButtonStyle::Outlined)
+                    .label_size(LabelSize::Small)
+                    .on_click({
+                        let server_id = server_id.clone();
+                        cx.listener(move |this, _event, _window, cx| {
+                            this.cancel_authentication(&server_id, cx);
+                        })
+                    }),
+            )
+    }
+
     fn render_modal_error(error: SharedString) -> Div {
         h_flex()
             .h_8()
@@ -1003,8 +1255,15 @@ impl Render for ConfigureContextServerModal {
                                             State::AuthRequired { server_id } => {
                                                 self.render_auth_required(&server_id.clone(), cx)
                                             }
-                                            State::Authenticating { .. } => {
-                                                self.render_loading("Authenticating…")
+                                            State::ClientSecretRequired { server_id, error } => {
+                                                self.render_client_secret_required(
+                                                    &server_id.clone(),
+                                                    error.clone(),
+                                                    cx,
+                                                )
+                                            }
+                                            State::Authenticating { server_id } => {
+                                                self.render_authenticating(&server_id.clone(), cx)
                                             }
                                             State::Error(error) => {
                                                 Self::render_modal_error(error.clone())
@@ -1040,7 +1299,9 @@ fn wait_for_context_server(
         }
 
         match status {
-            ContextServerStatus::Running | ContextServerStatus::AuthRequired => {
+            ContextServerStatus::Running
+            | ContextServerStatus::AuthRequired
+            | ContextServerStatus::ClientSecretRequired { .. } => {
                 if let Some(tx) = tx.lock().take() {
                     let _ = tx.send(Ok(status.clone()));
                 }
@@ -1104,3 +1365,52 @@ pub(crate) fn default_markdown_style(window: &Window, cx: &App) -> MarkdownStyle
         ..Default::default()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_http_input_reads_oauth_settings() {
+        let (id, url, headers, oauth) = parse_http_input(
+            r#"{
+  "figma": {
+    "url": "https://mcp.figma.com/mcp",
+    "oauth": {
+      "client_id": "client-id",
+      "client_secret": "client-secret"
+    },
+    "headers": {
+      "X-Test": "test"
+    }
+  }
+}"#,
+        )
+        .unwrap();
+
+        assert_eq!(id, ContextServerId("figma".into()));
+        assert_eq!(url, "https://mcp.figma.com/mcp");
+        assert_eq!(headers.get("X-Test"), Some(&String::from("test")));
+        let oauth = oauth.expect("oauth should be present");
+        assert_eq!(oauth.client_id, "client-id");
+        assert_eq!(oauth.client_secret.as_deref(), Some("client-secret"));
+    }
+
+    #[test]
+    fn context_server_http_input_preserves_existing_oauth_settings() {
+        let text = context_server_http_input(Some((
+            ContextServerId("figma".into()),
+            String::from("https://mcp.figma.com/mcp"),
+            HashMap::default(),
+            Some(OAuthClientSettings {
+                client_id: String::from("client-id"),
+                client_secret: Some(String::from("client-secret")),
+            }),
+        )));
+
+        let (_, _, _, oauth) = parse_http_input(&text).unwrap();
+        let oauth = oauth.expect("oauth should be present");
+        assert_eq!(oauth.client_id, "client-id");
+        assert_eq!(oauth.client_secret.as_deref(), Some("client-secret"));
+    }
+}
diff --git a/crates/context_server/src/oauth.rs b/crates/context_server/src/oauth.rs
index 098709555c8..7d50872900e 100644
--- a/crates/context_server/src/oauth.rs
+++ b/crates/context_server/src/oauth.rs
@@ -633,6 +633,26 @@ impl TokenResponse {
     }
 }
 
+/// An OAuth token error response (RFC 6749 Section 5.2).
+#[derive(Debug, Deserialize, PartialEq)]
+pub struct OAuthTokenError {
+    pub error: String,
+    #[serde(default)]
+    pub error_description: Option<String>,
+}
+
+impl std::fmt::Display for OAuthTokenError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "OAuth token error: {}", self.error)?;
+        if let Some(description) = &self.error_description {
+            write!(f, " ({description})")?;
+        }
+        Ok(())
+    }
+}
+
+impl std::error::Error for OAuthTokenError {}
+
 /// Build the form-encoded body for an authorization code token exchange.
 pub fn token_exchange_params(
     code: &str,
@@ -640,15 +660,20 @@ pub fn token_exchange_params(
     redirect_uri: &str,
     code_verifier: &str,
     resource: &str,
+    client_secret: Option<&str>,
 ) -> Vec<(&'static str, String)> {
-    vec![
+    let mut params = vec![
         ("grant_type", "authorization_code".to_string()),
         ("code", code.to_string()),
         ("redirect_uri", redirect_uri.to_string()),
         ("client_id", client_id.to_string()),
         ("code_verifier", code_verifier.to_string()),
         ("resource", resource.to_string()),
-    ]
+    ];
+    if let Some(secret) = client_secret {
+        params.push(("client_secret", secret.to_string()));
+    }
+    params
 }
 
 /// Build the form-encoded body for a token refresh request.
@@ -656,13 +681,18 @@ pub fn token_refresh_params(
     refresh_token: &str,
     client_id: &str,
     resource: &str,
+    client_secret: Option<&str>,
 ) -> Vec<(&'static str, String)> {
-    vec![
+    let mut params = vec![
         ("grant_type", "refresh_token".to_string()),
         ("refresh_token", refresh_token.to_string()),
         ("client_id", client_id.to_string()),
         ("resource", resource.to_string()),
-    ]
+    ];
+    if let Some(secret) = client_secret {
+        params.push(("client_secret", secret.to_string()));
+    }
+    params
 }
 
 // -- DCR request body (RFC 7591) ---------------------------------------------
@@ -782,6 +812,7 @@ pub async fn fetch_auth_server_metadata(
         match fetch_json::<AuthServerMetadataResponse>(http_client, url).await {
             Ok(response) => {
                 let reported_issuer = response.issuer.unwrap_or_else(|| issuer.clone());
+
                 if reported_issuer != *issuer {
                     bail!(
                         "Auth server metadata issuer mismatch: expected {}, got {}",
@@ -844,15 +875,6 @@ pub async fn discover(
         None => bail!("authorization server does not advertise code_challenge_methods_supported"),
     }
 
-    // Verify there is at least one supported registration strategy before we
-    // present the server as ready to authenticate.
-    match determine_registration_strategy(&auth_server_metadata) {
-        ClientRegistrationStrategy::Cimd { .. } | ClientRegistrationStrategy::Dcr { .. } => {}
-        ClientRegistrationStrategy::Unavailable => {
-            bail!("authorization server supports neither CIMD nor DCR")
-        }
-    }
-
     let scopes = select_scopes(www_authenticate, &resource_metadata);
 
     Ok(OAuthDiscovery {
@@ -956,8 +978,16 @@ pub async fn exchange_code(
     redirect_uri: &str,
     code_verifier: &str,
     resource: &str,
+    client_secret: Option<&str>,
 ) -> Result<OAuthTokens> {
-    let params = token_exchange_params(code, client_id, redirect_uri, code_verifier, resource);
+    let params = token_exchange_params(
+        code,
+        client_id,
+        redirect_uri,
+        code_verifier,
+        resource,
+        client_secret,
+    );
     post_token_request(http_client, &auth_server_metadata.token_endpoint, &params).await
 }
 
@@ -968,8 +998,9 @@ pub async fn refresh_tokens(
     refresh_token: &str,
     client_id: &str,
     resource: &str,
+    client_secret: Option<&str>,
 ) -> Result<OAuthTokens> {
-    let params = token_refresh_params(refresh_token, client_id, resource);
+    let params = token_refresh_params(refresh_token, client_id, resource, client_secret);
     post_token_request(http_client, token_endpoint, &params).await
 }
 
@@ -997,11 +1028,12 @@ async fn post_token_request(
     if !response.status().is_success() {
         let mut error_body = String::new();
         response.body_mut().read_to_string(&mut error_body).await?;
-        bail!(
-            "token request failed with status {}: {}",
-            response.status(),
-            error_body
-        );
+        let status = response.status();
+        // Try to parse as an OAuth error response (RFC 6749 Section 5.2).
+        if let Ok(token_error) = serde_json::from_str::<OAuthTokenError>(&error_body) {
+            return Err(token_error.into());
+        }
+        bail!("token request failed with status {status}: {error_body}");
     }
 
     let mut response_body = String::new();
@@ -1198,7 +1230,7 @@ impl OAuthTokenProvider for McpOAuthTokenProvider {
     }
 
     async fn try_refresh(&self) -> Result<bool> {
-        let (refresh_token, token_endpoint, resource, client_id) = {
+        let (refresh_token, token_endpoint, resource, client_id, client_secret) = {
             let session = self.session.lock();
             match session.tokens.refresh_token.clone() {
                 Some(refresh_token) => (
@@ -1206,6 +1238,7 @@ impl OAuthTokenProvider for McpOAuthTokenProvider {
                     session.token_endpoint.clone(),
                     session.resource.clone(),
                     session.client_registration.client_id.clone(),
+                    session.client_registration.client_secret.clone(),
                 ),
                 None => return Ok(false),
             }
@@ -1219,6 +1252,7 @@ impl OAuthTokenProvider for McpOAuthTokenProvider {
             &refresh_token,
             &client_id,
             &resource_str,
+            client_secret.as_deref(),
         )
         .await
         {
@@ -1801,6 +1835,7 @@ mod tests {
             "http://127.0.0.1:5555/callback",
             "verifier_123",
             "https://mcp.example.com",
+            None,
         );
         let map: std::collections::HashMap<&str, &str> =
             params.iter().map(|(k, v)| (*k, v.as_str())).collect();
@@ -1815,8 +1850,12 @@ mod tests {
 
     #[test]
     fn test_token_refresh_params() {
-        let params =
-            token_refresh_params("refresh_token_abc", "client_xyz", "https://mcp.example.com");
+        let params = token_refresh_params(
+            "refresh_token_abc",
+            "client_xyz",
+            "https://mcp.example.com",
+            None,
+        );
         let map: std::collections::HashMap<&str, &str> =
             params.iter().map(|(k, v)| (*k, v.as_str())).collect();
 
@@ -2422,6 +2461,7 @@ mod tests {
                 "http://127.0.0.1:9999/callback",
                 "verifier_abc",
                 "https://mcp.example.com",
+                None,
             )
             .await
             .unwrap();
@@ -2461,6 +2501,7 @@ mod tests {
                 "old_refresh_token",
                 CIMD_URL,
                 "https://mcp.example.com",
+                None,
             )
             .await
             .unwrap();
@@ -2497,11 +2538,21 @@ mod tests {
                 "http://127.0.0.1:1/callback",
                 "verifier",
                 "https://mcp.example.com",
+                None,
             )
             .await;
 
-            assert!(result.is_err());
-            assert!(result.unwrap_err().to_string().contains("400"));
+            let err = result.unwrap_err();
+            let token_error = err
+                .downcast_ref::<OAuthTokenError>()
+                .expect("expected OAuthTokenError");
+            assert_eq!(
+                *token_error,
+                OAuthTokenError {
+                    error: "invalid_grant".into(),
+                    error_description: None,
+                }
+            );
         });
     }
 
diff --git a/crates/project/src/context_server_store.rs b/crates/project/src/context_server_store.rs
index 6e231453e41..35651a7ff4b 100644
--- a/crates/project/src/context_server_store.rs
+++ b/crates/project/src/context_server_store.rs
@@ -27,7 +27,7 @@ use util::{ResultExt as _, rel_path::RelPath};
 
 use crate::{
     DisableAiSettings, Project,
-    project_settings::{ContextServerSettings, ProjectSettings},
+    project_settings::{ContextServerSettings, OAuthClientSettings, ProjectSettings},
     worktree_store::{WorktreeStore, WorktreeStoreEvent},
 };
 
@@ -56,6 +56,11 @@ pub enum ContextServerStatus {
     /// The server returned 401 and OAuth authorization is needed. The UI
     /// should show an "Authenticate" button.
     AuthRequired,
+    /// The server has a pre-registered OAuth client_id, but a client_secret
+    /// is needed and not available in settings or the keychain.
+    ClientSecretRequired {
+        error: Option<Arc<str>>,
+    },
     /// The OAuth browser flow is in progress — the user has been redirected
     /// to the authorization server and we're waiting for the callback.
     Authenticating,
@@ -69,6 +74,11 @@ impl ContextServerStatus {
             ContextServerState::Stopped { .. } => ContextServerStatus::Stopped,
             ContextServerState::Error { error, .. } => ContextServerStatus::Error(error.clone()),
             ContextServerState::AuthRequired { .. } => ContextServerStatus::AuthRequired,
+            ContextServerState::ClientSecretRequired { error, .. } => {
+                ContextServerStatus::ClientSecretRequired {
+                    error: error.clone(),
+                }
+            }
             ContextServerState::Authenticating { .. } => ContextServerStatus::Authenticating,
         }
     }
@@ -100,6 +110,14 @@ enum ContextServerState {
         configuration: Arc<ContextServerConfiguration>,
         discovery: Arc<OAuthDiscovery>,
     },
+    /// A pre-registered client_id is configured but no client_secret was found
+    /// in settings or the keychain.
+    ClientSecretRequired {
+        server: Arc<ContextServer>,
+        configuration: Arc<ContextServerConfiguration>,
+        discovery: Arc<OAuthDiscovery>,
+        error: Option<Arc<str>>,
+    },
     /// The OAuth browser flow is in progress. The user has been redirected
     /// to the authorization server and we're waiting for the callback.
     Authenticating {
@@ -117,6 +135,7 @@ impl ContextServerState {
             | ContextServerState::Stopped { server, .. }
             | ContextServerState::Error { server, .. }
             | ContextServerState::AuthRequired { server, .. }
+            | ContextServerState::ClientSecretRequired { server, .. }
             | ContextServerState::Authenticating { server, .. } => server.clone(),
         }
     }
@@ -128,6 +147,7 @@ impl ContextServerState {
             | ContextServerState::Stopped { configuration, .. }
             | ContextServerState::Error { configuration, .. }
             | ContextServerState::AuthRequired { configuration, .. }
+            | ContextServerState::ClientSecretRequired { configuration, .. }
             | ContextServerState::Authenticating { configuration, .. } => configuration.clone(),
         }
     }
@@ -148,6 +168,7 @@ pub enum ContextServerConfiguration {
         url: url::Url,
         headers: HashMap<String, String>,
         timeout: Option<u64>,
+        oauth: Option<OAuthClientSettings>,
     },
 }
 
@@ -228,12 +249,14 @@ impl ContextServerConfiguration {
                 url,
                 headers: auth,
                 timeout,
+                oauth,
             } => {
                 let url = url::Url::parse(&url).log_err()?;
                 Some(ContextServerConfiguration::Http {
                     url,
                     headers: auth,
                     timeout,
+                    oauth,
                 })
             }
         }
@@ -841,6 +864,7 @@ impl ContextServerStore {
                     url,
                     headers,
                     timeout,
+                    oauth: _,
                 } => {
                     let transport = HttpTransport::new_with_token_provider(
                         cx.http_client(),
@@ -1007,6 +1031,15 @@ impl ContextServerStore {
             _ => anyhow::bail!("Server is not in AuthRequired state"),
         };
 
+        let needs_keychain_check = match configuration.as_ref() {
+            ContextServerConfiguration::Http {
+                url,
+                oauth: Some(oauth_settings),
+                ..
+            } if oauth_settings.client_secret.is_none() => Some(url.clone()),
+            _ => None,
+        };
+
         let id = id.clone();
 
         let task = cx.spawn({
@@ -1014,6 +1047,33 @@ impl ContextServerStore {
             let server = server.clone();
             let configuration = configuration.clone();
             async move |this, cx| {
+                if let Some(server_url) = needs_keychain_check {
+                    let credentials_provider = cx.update(|cx| zed_credentials_provider::global(cx));
+                    let has_keychain_secret =
+                        Self::load_client_secret(&credentials_provider, &server_url, cx)
+                            .await
+                            .ok()
+                            .flatten()
+                            .is_some();
+
+                    if !has_keychain_secret {
+                        this.update(cx, |this, cx| {
+                            this.update_server_state(
+                                id.clone(),
+                                ContextServerState::ClientSecretRequired {
+                                    server,
+                                    configuration,
+                                    discovery,
+                                    error: None,
+                                },
+                                cx,
+                            );
+                        })
+                        .log_err();
+                        return;
+                    }
+                }
+
                 let result = Self::run_oauth_flow(
                     this.clone(),
                     id.clone(),
@@ -1025,15 +1085,13 @@ impl ContextServerStore {
 
                 if let Err(err) = &result {
                     log::error!("{} OAuth authentication failed: {:?}", id, err);
-                    // Transition back to AuthRequired so the user can retry
-                    // rather than landing in a terminal Error state.
                     this.update(cx, |this, cx| {
                         this.update_server_state(
                             id.clone(),
-                            ContextServerState::AuthRequired {
+                            ContextServerState::Error {
                                 server,
                                 configuration,
-                                discovery,
+                                error: format!("{err:#}").into(),
                             },
                             cx,
                         )
@@ -1056,6 +1114,121 @@ impl ContextServerStore {
         Ok(())
     }
 
+    /// Store the client secret and proceed with authentication.
+    pub fn submit_client_secret(
+        &mut self,
+        id: &ContextServerId,
+        secret: String,
+        cx: &mut Context<Self>,
+    ) -> Result<()> {
+        let state = self.servers.get(id).context("Context server not found")?;
+
+        let (server, configuration, discovery) = match state {
+            ContextServerState::ClientSecretRequired {
+                server,
+                configuration,
+                discovery,
+                ..
+            } => (server.clone(), configuration.clone(), discovery.clone()),
+            _ => anyhow::bail!("Server is not in ClientSecretRequired state"),
+        };
+
+        let server_url = match configuration.as_ref() {
+            ContextServerConfiguration::Http { url, .. } => url.clone(),
+            _ => anyhow::bail!("OAuth only supported for HTTP servers"),
+        };
+
+        let id = id.clone();
+
+        let task = cx.spawn({
+            let id = id.clone();
+            let server = server.clone();
+            let configuration = configuration.clone();
+            async move |this, cx| {
+                // Store the secret if non-empty (empty means public client / skip).
+                if !secret.is_empty() {
+                    let credentials_provider = cx.update(|cx| zed_credentials_provider::global(cx));
+                    if let Err(err) =
+                        Self::store_client_secret(&credentials_provider, &server_url, &secret, cx)
+                            .await
+                    {
+                        log::error!(
+                            "{} failed to store client secret in keychain: {:?}",
+                            id,
+                            err
+                        );
+                    }
+                }
+
+                let result = Self::run_oauth_flow(
+                    this.clone(),
+                    id.clone(),
+                    discovery.clone(),
+                    configuration.clone(),
+                    cx,
+                )
+                .await;
+
+                if let Err(err) = &result {
+                    log::error!("{} OAuth authentication failed: {:?}", id, err);
+
+                    let is_bad_client_credentials = err
+                        .downcast_ref::<oauth::OAuthTokenError>()
+                        .is_some_and(|e| e.error == "unauthorized_client");
+
+                    if is_bad_client_credentials {
+                        // Clear the bad secret from the keychain so the user
+                        // gets a fresh prompt.
+                        let credentials_provider =
+                            cx.update(|cx| zed_credentials_provider::global(cx));
+                        Self::clear_client_secret(&credentials_provider, &server_url, cx)
+                            .await
+                            .log_err();
+
+                        this.update(cx, |this, cx| {
+                            this.update_server_state(
+                                id.clone(),
+                                ContextServerState::ClientSecretRequired {
+                                    server,
+                                    configuration,
+                                    discovery,
+                                    error: Some(format!("{err:#}").into()),
+                                },
+                                cx,
+                            );
+                        })
+                        .log_err();
+                    } else {
+                        this.update(cx, |this, cx| {
+                            this.update_server_state(
+                                id.clone(),
+                                ContextServerState::Error {
+                                    server,
+                                    configuration,
+                                    error: format!("{err:#}").into(),
+                                },
+                                cx,
+                            )
+                        })
+                        .log_err();
+                    }
+                }
+            }
+        });
+
+        self.update_server_state(
+            id,
+            ContextServerState::Authenticating {
+                server,
+                configuration,
+                _task: task,
+            },
+            cx,
+        );
+
+        Ok(())
+    }
+
     async fn run_oauth_flow(
         this: WeakEntity<Self>,
         id: ContextServerId,
@@ -1083,10 +1256,30 @@ impl ContextServerStore {
             _ => anyhow::bail!("OAuth authentication only supported for HTTP servers"),
         };
 
-        let client_registration =
-            oauth::resolve_client_registration(&http_client, &discovery, &redirect_uri)
+        let client_registration = match configuration.as_ref() {
+            ContextServerConfiguration::Http {
+                url,
+                oauth: Some(oauth_settings),
+                ..
+            } => {
+                // Pre-registered client. Resolve the secret from settings, then keychain.
+                let client_secret = if oauth_settings.client_secret.is_some() {
+                    oauth_settings.client_secret.clone()
+                } else {
+                    Self::load_client_secret(&credentials_provider, url, cx)
+                        .await
+                        .ok()
+                        .flatten()
+                };
+                oauth::OAuthClientRegistration {
+                    client_id: oauth_settings.client_id.clone(),
+                    client_secret,
+                }
+            }
+            _ => oauth::resolve_client_registration(&http_client, &discovery, &redirect_uri)
                 .await
-                .context("Failed to resolve OAuth client registration")?;
+                .context("Failed to resolve OAuth client registration")?,
+        };
 
         let auth_url = oauth::build_authorization_url(
             &discovery.auth_server_metadata,
@@ -1116,6 +1309,7 @@ impl ContextServerStore {
             &redirect_uri,
             &pkce.verifier,
             &resource,
+            client_registration.client_secret.as_deref(),
         )
         .await
         .context("Failed to exchange authorization code for tokens")?;
@@ -1149,6 +1343,7 @@ impl ContextServerStore {
                     url,
                     headers,
                     timeout,
+                    oauth: _,
                 } => {
                     let transport = HttpTransport::new_with_token_provider(
                         http_client.clone(),
@@ -1222,6 +1417,46 @@ impl ContextServerStore {
         format!("mcp-oauth:{}", oauth::canonical_server_uri(server_url))
     }
 
+    fn client_secret_keychain_key(server_url: &url::Url) -> String {
+        format!(
+            "mcp-oauth-client-secret:{}",
+            oauth::canonical_server_uri(server_url)
+        )
+    }
+
+    async fn load_client_secret(
+        credentials_provider: &Arc<dyn CredentialsProvider>,
+        server_url: &url::Url,
+        cx: &AsyncApp,
+    ) -> Result<Option<String>> {
+        let key = Self::client_secret_keychain_key(server_url);
+        match credentials_provider.read_credentials(&key, cx).await? {
+            Some((_username, secret_bytes)) => Ok(Some(String::from_utf8(secret_bytes)?)),
+            None => Ok(None),
+        }
+    }
+
+    pub async fn store_client_secret(
+        credentials_provider: &Arc<dyn CredentialsProvider>,
+        server_url: &url::Url,
+        secret: &str,
+        cx: &AsyncApp,
+    ) -> Result<()> {
+        let key = Self::client_secret_keychain_key(server_url);
+        credentials_provider
+            .write_credentials(&key, "mcp-oauth-client-secret", secret.as_bytes(), cx)
+            .await
+    }
+
+    async fn clear_client_secret(
+        credentials_provider: &Arc<dyn CredentialsProvider>,
+        server_url: &url::Url,
+        cx: &AsyncApp,
+    ) -> Result<()> {
+        let key = Self::client_secret_keychain_key(server_url);
+        credentials_provider.delete_credentials(&key, cx).await
+    }
+
     /// Log out of an OAuth-authenticated MCP server: clear the stored OAuth
     /// session from the keychain and stop the server.
     pub fn logout_server(&mut self, id: &ContextServerId, cx: &mut Context<Self>) -> Result<()> {
@@ -1241,6 +1476,11 @@ impl ContextServerStore {
             if let Err(err) = Self::clear_session(&credentials_provider, &server_url, &cx).await {
                 log::error!("{} failed to clear OAuth session: {}", id, err);
             }
+            // Also clear any client secret so the user gets a fresh prompt on
+            // the next authentication attempt.
+            Self::clear_client_secret(&credentials_provider, &server_url, &cx)
+                .await
+                .log_err();
             // Trigger server recreation so the next start uses a fresh
             // transport without the old (now-invalidated) token provider.
             this.update(cx, |this, cx| {
@@ -1487,6 +1727,34 @@ async fn resolve_start_failure(
 
     match context_server::oauth::discover(&http_client, &server_url, www_authenticate).await {
         Ok(discovery) => {
+            use context_server::oauth::{
+                ClientRegistrationStrategy, determine_registration_strategy,
+            };
+
+            let has_preregistered_client_id = matches!(
+                configuration.as_ref(),
+                ContextServerConfiguration::Http { oauth: Some(_), .. }
+            );
+
+            let strategy = determine_registration_strategy(&discovery.auth_server_metadata);
+
+            if matches!(strategy, ClientRegistrationStrategy::Unavailable)
+                && !has_preregistered_client_id
+            {
+                log::error!(
+                    "{id} authorization server supports neither CIMD nor DCR, \
+                     and no pre-registered client_id is configured"
+                );
+                return ContextServerState::Error {
+                    configuration,
+                    server,
+                    error: "Authorization server supports neither CIMD nor DCR. \
+                            Configure a pre-registered client_id in your settings \
+                            under the \"oauth\" key."
+                        .into(),
+                };
+            }
+
             log::info!(
                 "{id} requires OAuth authorization (auth server: {})",
                 discovery.auth_server_metadata.issuer,
diff --git a/crates/project/src/project_settings.rs b/crates/project/src/project_settings.rs
index d2dc70b8392..f11263a8f70 100644
--- a/crates/project/src/project_settings.rs
+++ b/crates/project/src/project_settings.rs
@@ -201,6 +201,10 @@ pub enum ContextServerSettings {
         headers: HashMap<String, String>,
         /// Timeout for tool calls in milliseconds.
         timeout: Option<u64>,
+        /// Pre-registered OAuth client credentials for authorization servers that
+        /// require out-of-band client registration.
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        oauth: Option<OAuthClientSettings>,
     },
     Extension {
         /// Whether the context server is enabled.
@@ -243,11 +247,16 @@ impl From<settings::ContextServerSettingsContent> for ContextServerSettings {
                 url,
                 headers,
                 timeout,
+                oauth,
             } => ContextServerSettings::Http {
                 enabled,
                 url,
                 headers,
                 timeout,
+                oauth: oauth.map(|o| OAuthClientSettings {
+                    client_id: o.client_id,
+                    client_secret: o.client_secret,
+                }),
             },
         }
     }
@@ -278,16 +287,35 @@ impl Into<settings::ContextServerSettingsContent> for ContextServerSettings {
                 url,
                 headers,
                 timeout,
+                oauth,
             } => settings::ContextServerSettingsContent::Http {
                 enabled,
                 url,
                 headers,
                 timeout,
+                oauth: oauth.map(|o| settings::OAuthClientSettings {
+                    client_id: o.client_id,
+                    client_secret: o.client_secret,
+                }),
             },
         }
     }
 }
 
+/// Pre-registered OAuth client credentials for MCP servers that don't support
+/// Dynamic Client Registration.
+#[derive(Deserialize, Serialize, Clone, PartialEq, Eq, JsonSchema, Debug)]
+pub struct OAuthClientSettings {
+    /// The OAuth client ID obtained from out-of-band registration with the
+    /// authorization server.
+    pub client_id: String,
+    /// The OAuth client secret, if this is a confidential client. For security,
+    /// prefer providing this interactively; we will prompt and store it in
+    /// the system keychain.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<String>,
+}
+
 impl ContextServerSettings {
     pub fn default_extension() -> Self {
         Self::Extension {
diff --git a/crates/project/tests/integration/context_server_store.rs b/crates/project/tests/integration/context_server_store.rs
index f9dbce84a17..090baacf032 100644
--- a/crates/project/tests/integration/context_server_store.rs
+++ b/crates/project/tests/integration/context_server_store.rs
@@ -897,6 +897,7 @@ async fn test_remote_context_server(cx: &mut TestAppContext) {
                 url: server_url.to_string(),
                 headers: Default::default(),
                 timeout: None,
+                oauth: None,
             },
         )],
         cx,
@@ -963,6 +964,7 @@ async fn test_context_server_global_timeout(cx: &mut TestAppContext) {
             url: url::Url::parse("http://localhost:8080").expect("Failed to parse test URL"),
             headers: Default::default(),
             timeout: None,
+            oauth: None,
         }),
         &mut async_cx,
     )
@@ -998,6 +1000,7 @@ async fn test_context_server_per_server_timeout_override(cx: &mut TestAppContext
                 url: "http://localhost:8080".to_string(),
                 headers: Default::default(),
                 timeout: Some(120),
+                oauth: None,
             },
         )],
     )
@@ -1021,6 +1024,7 @@ async fn test_context_server_per_server_timeout_override(cx: &mut TestAppContext
             url: url::Url::parse("http://localhost:8080").expect("Failed to parse test URL"),
             headers: Default::default(),
             timeout: Some(120),
+            oauth: None,
         }),
         &mut async_cx,
     )
diff --git a/crates/settings_content/src/project.rs b/crates/settings_content/src/project.rs
index 93ef9a36293..fbeede37871 100644
--- a/crates/settings_content/src/project.rs
+++ b/crates/settings_content/src/project.rs
@@ -388,6 +388,10 @@ pub enum ContextServerSettingsContent {
         headers: HashMap<String, String>,
         /// Timeout for tool calls in seconds. Defaults to global context_server_timeout if not specified.
         timeout: Option<u64>,
+        /// Pre-registered OAuth client credentials for authorization servers that
+        /// require out-of-band client registration.
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        oauth: Option<OAuthClientSettings>,
     },
     Extension {
         /// Whether the context server is enabled.
@@ -429,6 +433,20 @@ impl ContextServerSettingsContent {
     }
 }
 
+/// Pre-registered OAuth client credentials for MCP servers that don't support
+/// Dynamic Client Registration.
+#[derive(Deserialize, Serialize, Clone, PartialEq, Eq, JsonSchema, MergeFrom, Debug)]
+pub struct OAuthClientSettings {
+    /// The OAuth client ID obtained from out-of-band registration with the
+    /// authorization server.
+    pub client_id: String,
+    /// The OAuth client secret, if this is a confidential client. For security,
+    /// prefer providing this interactively; we will prompt and store it in
+    /// the system keychain.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<String>,
+}
+
 #[with_fallible_options]
 #[derive(Deserialize, Serialize, Clone, PartialEq, Eq, JsonSchema, MergeFrom)]
 pub struct ContextServerCommand {
diff --git a/crates/ui/src/components/ai/ai_setting_item.rs b/crates/ui/src/components/ai/ai_setting_item.rs
index bfb55e4c7da..6651ee1b769 100644
--- a/crates/ui/src/components/ai/ai_setting_item.rs
+++ b/crates/ui/src/components/ai/ai_setting_item.rs
@@ -10,6 +10,7 @@ pub enum AiSettingItemStatus {
     Running,
     Error,
     AuthRequired,
+    ClientSecretRequired,
     Authenticating,
 }
 
@@ -21,6 +22,7 @@ impl AiSettingItemStatus {
             Self::Running => "Server is active.",
             Self::Error => "Server has an error.",
             Self::AuthRequired => "Authentication required.",
+            Self::ClientSecretRequired => "Client secret required.",
             Self::Authenticating => "Waiting for authorization…",
         }
     }
@@ -31,7 +33,7 @@ impl AiSettingItemStatus {
             Self::Starting | Self::Authenticating => Some(Color::Muted),
             Self::Running => Some(Color::Success),
             Self::Error => Some(Color::Error),
-            Self::AuthRequired => Some(Color::Warning),
+            Self::AuthRequired | Self::ClientSecretRequired => Some(Color::Warning),
         }
     }
 

From 57a64fc824db20a6b002761d5be8d2b90d40d279 Mon Sep 17 00:00:00 2001
From: Cole Miller <cole@zed.dev>
Date: Tue, 19 May 2026 13:53:00 -0400
Subject: [PATCH 034/105] Add some more logging to diagnose lost FS events and
 stale git state (#57173)

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Release Notes:

- N/A

---------

Co-authored-by: Ben Kunkle <ben@zed.dev>
---
 crates/fs/src/fs.rs                       |  1 +
 crates/fs/src/fs_watcher.rs               |  2 +-
 crates/project/src/git_store.rs           |  1 +
 crates/worktree/src/worktree.rs           | 24 ++++++++++++++-----
 crates/worktree/tests/integration/main.rs | 28 +++++++++++++++++++++++
 5 files changed, 49 insertions(+), 7 deletions(-)

diff --git a/crates/fs/src/fs.rs b/crates/fs/src/fs.rs
index 2d716f8e519..eed246b37ae 100644
--- a/crates/fs/src/fs.rs
+++ b/crates/fs/src/fs.rs
@@ -1257,6 +1257,7 @@ impl Fs for RealFs {
                     async move {
                         executor.timer(latency).await;
                         let paths = std::mem::take(&mut *pending_paths.lock());
+                        log::debug!("pending path events: {:?}", paths);
                         (!paths.is_empty()).then_some(paths)
                     }
                 }
diff --git a/crates/fs/src/fs_watcher.rs b/crates/fs/src/fs_watcher.rs
index ef676e9ed02..85d1e164c0b 100644
--- a/crates/fs/src/fs_watcher.rs
+++ b/crates/fs/src/fs_watcher.rs
@@ -164,7 +164,7 @@ fn push_notify_event(
             kind: Some(PathEventKind::Rescan),
         });
     }
-
+    log::trace!("path_events: {:?}", path_events);
     enqueue_path_events(tx, pending_path_events, path_events);
 }
 
diff --git a/crates/project/src/git_store.rs b/crates/project/src/git_store.rs
index 9f97f829b0c..ee6063c0e4e 100644
--- a/crates/project/src/git_store.rs
+++ b/crates/project/src/git_store.rs
@@ -1498,6 +1498,7 @@ impl GitStore {
                 else {
                     return;
                 };
+                log::debug!("received worktree update for repositories: {changed_repos:?}");
                 self.update_repositories_from_worktree(
                     *worktree_id,
                     project_environment.clone(),
diff --git a/crates/worktree/src/worktree.rs b/crates/worktree/src/worktree.rs
index a21ea8f639e..f1dfaec5c85 100644
--- a/crates/worktree/src/worktree.rs
+++ b/crates/worktree/src/worktree.rs
@@ -8,7 +8,8 @@ use clock::ReplicaId;
 use collections::{HashMap, HashSet, VecDeque};
 use encoding_rs::Encoding;
 use fs::{
-    Fs, MTime, PathEvent, RemoveOptions, TrashedEntry, Watcher, copy_recursive, read_dir_items,
+    Fs, MTime, PathEvent, PathEventKind, RemoveOptions, TrashedEntry, Watcher, copy_recursive,
+    read_dir_items,
 };
 use futures::{
     FutureExt as _, Stream, StreamExt,
@@ -4374,6 +4375,8 @@ impl BackgroundScanner {
             events = Self::normalized_events_for_worktree(&state, &root_canonical_path, events);
         }
 
+        log::debug!("raw events for process_events: {events:?}");
+
         fn skip_ix(ranges: &mut SmallVec<[Range<usize>; 4]>, ix: usize) {
             if let Some(last_range) = ranges.last_mut()
                 && last_range.end == ix
@@ -4418,20 +4421,29 @@ impl BackgroundScanner {
                 }
 
                 if let Some((dot_git_abs_path, path_in_git_dir)) = dot_git_paths {
-                    let skip = skipped_files_in_dot_git.iter().any(|skipped| {
+                    let is_ignored = skipped_files_in_dot_git.iter().any(|skipped| {
                         OsStr::new(skipped) == path_in_git_dir.as_path().as_os_str()
                     }) || skipped_dirs_in_dot_git
                         .iter()
-                        .any(|skipped_git_subdir| path_in_git_dir.starts_with(skipped_git_subdir))
-                        || path_in_git_dir == Path::new("")
-                            && self.fs.is_dir(&dot_git_abs_path).await;
-                    if skip {
+                        .any(|skipped_git_subdir| path_in_git_dir.starts_with(skipped_git_subdir));
+                    let is_dot_git = path_in_git_dir == Path::new("")
+                        && matches!(event.kind, Some(PathEventKind::Changed))
+                        && self.fs.is_dir(&dot_git_abs_path).await;
+                    if is_ignored {
                         log::debug!(
                             "ignoring event {abs_path:?} as it's in the .git directory among skipped files or directories"
                         );
                         skip_ix(&mut ranges_to_drop, ix);
                         continue;
                     }
+                    if is_dot_git {
+                        log::debug!(
+                            "ignoring event {abs_path:?} for .git directory itself (kind: {:?})",
+                            event.kind
+                        );
+                        skip_ix(&mut ranges_to_drop, ix);
+                        continue;
+                    }
 
                     if !dot_git_abs_paths.contains(&dot_git_abs_path) {
                         dot_git_abs_paths.push(dot_git_abs_path);
diff --git a/crates/worktree/tests/integration/main.rs b/crates/worktree/tests/integration/main.rs
index ef5180a7083..f8e07ffa0b4 100644
--- a/crates/worktree/tests/integration/main.rs
+++ b/crates/worktree/tests/integration/main.rs
@@ -3584,6 +3584,34 @@ async fn test_dot_git_dir_event_does_not_suppress_children(
             "should emit UpdatedGitRepositories for a .git/index event"
         );
     }
+
+    {
+        let mut events = cx.events(&worktree);
+        fs.pause_events();
+        fs.emit_fs_event(dot_git, Some(PathEventKind::Rescan));
+        fs.unpause_events_and_flush();
+        executor.run_until_parked();
+
+        let got_git_update = drain_git_repo_updates(&mut events);
+        assert!(
+            got_git_update,
+            "should emit UpdatedGitRepositories for a .git rescan event"
+        );
+    }
+
+    {
+        let mut events = cx.events(&worktree);
+        fs.pause_events();
+        fs.emit_fs_event(project_dir, Some(PathEventKind::Rescan));
+        fs.unpause_events_and_flush();
+        executor.run_until_parked();
+
+        let got_git_update = drain_git_repo_updates(&mut events);
+        assert!(
+            got_git_update,
+            "should emit UpdatedGitRepositories for a .git rescan event"
+        );
+    }
 }
 
 fn drain_git_repo_updates(events: &mut futures::channel::mpsc::UnboundedReceiver<Event>) -> bool {

From a0aa3e842f9ca65d7679a2aced0b2214dcf765c4 Mon Sep 17 00:00:00 2001
From: Ben Kunkle <ben@zed.dev>
Date: Tue, 19 May 2026 13:55:54 -0400
Subject: [PATCH 035/105] fs: Poll until watched path is created instead of
 watching parent (#57152)

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [ ] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Closes #ISSUE

Part of FR-9.

Release Notes:

- N/A or Added/Fixed/Improved ...
---
 crates/fs/src/fs.rs         | 153 +-----------------
 crates/fs/src/fs_watcher.rs | 308 +++++++++++++++++++++++++++++++-----
 2 files changed, 275 insertions(+), 186 deletions(-)

diff --git a/crates/fs/src/fs.rs b/crates/fs/src/fs.rs
index eed246b37ae..7809e65eeb3 100644
--- a/crates/fs/src/fs.rs
+++ b/crates/fs/src/fs.rs
@@ -1,5 +1,7 @@
 pub mod fs_watcher;
 
+pub use fs_watcher::requires_poll_watcher;
+
 use parking_lot::Mutex;
 use std::ffi::OsString;
 use std::sync::atomic::{AtomicU8, AtomicUsize, Ordering};
@@ -71,133 +73,6 @@ pub trait Watcher: Send + Sync {
     fn remove(&self, path: &Path) -> Result<()>;
 }
 
-/// Detect whether a path requires polling instead of native file watching.
-///
-/// Returns `true` for filesystem types where inotify/FSEvents/ReadDirectoryChanges
-/// silently fail to deliver events: 9P (WSL drvfs), NFS, CIFS/SMB, FUSE (sshfs), etc.
-///
-/// Can be overridden with the `ZED_FILE_WATCHER_MODE` environment variable:
-/// - `native` — always use native OS watcher
-/// - `poll` — always use polling
-/// - `auto` (default) — auto-detect based on filesystem type
-pub fn requires_poll_watcher(path: &Path) -> bool {
-    match std::env::var("ZED_FILE_WATCHER_MODE")
-        .as_deref()
-        .unwrap_or("auto")
-    {
-        "native" => return false,
-        "poll" => return true,
-        _ => {}
-    }
-
-    #[cfg(target_os = "linux")]
-    {
-        let path = effective_watch_path(path);
-        return detect_requires_poll_watcher_linux(&path);
-    }
-
-    #[cfg(not(target_os = "linux"))]
-    {
-        let _ = path;
-        false
-    }
-}
-
-pub fn effective_watch_path(path: &Path) -> PathBuf {
-    if path.exists() {
-        return path.to_path_buf();
-    }
-
-    for ancestor in path.ancestors() {
-        if ancestor.exists() {
-            return ancestor.to_path_buf();
-        }
-    }
-
-    path.to_path_buf()
-}
-
-#[cfg(target_os = "linux")]
-fn detect_requires_poll_watcher_linux(path: &Path) -> bool {
-    use std::ffi::CString;
-    use std::os::unix::ffi::OsStrExt;
-
-    // Check filesystem type via statfs
-    let c_path = match CString::new(path.as_os_str().as_bytes()) {
-        Ok(p) => p,
-        Err(_) => return false,
-    };
-
-    let mut stat: libc::statfs = unsafe { std::mem::zeroed() };
-    if unsafe { libc::statfs(c_path.as_ptr(), &mut stat) } != 0 {
-        return false;
-    }
-
-    // Filesystem magic numbers where inotify does not deliver events.
-    // These are defined in linux/magic.h and statfs(2).
-    const V9FS_MAGIC: u64 = 0x0102_1997; // Plan 9 / WSL2 interop (drvfs)
-    const NFS_SUPER_MAGIC: u64 = 0x0000_6969;
-    const CIFS_MAGIC: u64 = 0xFF53_4D42; // CIFS/SMB
-    const SMB_SUPER_MAGIC: u64 = 0x0000_517B;
-    const SMB2_MAGIC: u64 = 0xFE53_4D42;
-    const FUSE_SUPER_MAGIC: u64 = 0x6573_5546; // FUSE (includes sshfs)
-
-    let fs_type = (stat.f_type as u64) & 0xFFFF_FFFF;
-    if fs_type == V9FS_MAGIC
-        || fs_type == NFS_SUPER_MAGIC
-        || fs_type == CIFS_MAGIC
-        || fs_type == SMB_SUPER_MAGIC
-        || fs_type == SMB2_MAGIC
-        || fs_type == FUSE_SUPER_MAGIC
-    {
-        log::info!(
-            "Detected network/virtual filesystem (type 0x{:x}) at {}, using poll watcher",
-            fs_type,
-            path.display()
-        );
-        return true;
-    }
-
-    // Also check for WSL + /mnt/<drive>/ pattern as a fallback
-    // in case statfs returns an unexpected type for drvfs
-    if is_wsl_drvfs_path(path) {
-        log::info!(
-            "Detected WSL drvfs mount at {}, using poll watcher",
-            path.display()
-        );
-        return true;
-    }
-
-    false
-}
-
-#[cfg(target_os = "linux")]
-fn is_wsl_drvfs_path(path: &Path) -> bool {
-    // Only relevant inside WSL
-    if std::env::var_os("WSL_DISTRO_NAME").is_none() {
-        if let Ok(version) = std::fs::read_to_string("/proc/version") {
-            let v = version.to_lowercase();
-            if !v.contains("microsoft") && !v.contains("wsl") {
-                return false;
-            }
-        } else {
-            return false;
-        }
-    }
-
-    // Windows drives are mounted at /mnt/c, /mnt/d, etc.
-    let path_str = match path.to_str() {
-        Some(s) => s,
-        None => return false,
-    };
-    if !path_str.starts_with("/mnt/") || path_str.len() < 6 {
-        return false;
-    }
-    let after_mnt = &path_str[5..];
-    after_mnt.starts_with(|c: char| c.is_ascii_alphabetic())
-        && (after_mnt.len() == 1 || after_mnt.as_bytes()[1] == b'/')
-}
-
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug)]
 pub enum PathEventKind {
     Removed,
@@ -1197,35 +1072,17 @@ impl Fs for RealFs {
         use util::{ResultExt as _, paths::SanitizedPath};
         let executor = self.executor.clone();
 
-        let use_poll = requires_poll_watcher(path);
-        let watch_path = effective_watch_path(path);
-
         let (tx, rx) = async_channel::unbounded();
         let pending_paths: Arc<Mutex<Vec<PathEvent>>> = Default::default();
 
-        let mode = if use_poll {
-            log::info!(
-                "Using poll watcher ({}ms interval) for {}",
-                fs_watcher::poll_interval().as_millis(),
-                path.display()
-            );
-            telemetry::event!("fs_watcher_poll", path = path.display().to_string());
-            fs_watcher::WatcherMode::Poll
-        } else {
-            fs_watcher::WatcherMode::Native
-        };
         let watcher: Arc<dyn Watcher> = Arc::new(fs_watcher::FsWatcher::new(
+            executor.clone(),
             tx.clone(),
             pending_paths.clone(),
-            mode,
         ));
 
-        if let Err(e) = watcher.add(&watch_path) {
-            log::warn!(
-                "Failed to watch {} using {}:\n{e}",
-                path.display(),
-                watch_path.display()
-            );
+        if let Err(e) = watcher.add(path) {
+            log::warn!("Failed to watch {}:\n{e}", path.display());
         }
 
         // Check if path is a symlink and follow the target parent
diff --git a/crates/fs/src/fs_watcher.rs b/crates/fs/src/fs_watcher.rs
index 85d1e164c0b..2c8078f1324 100644
--- a/crates/fs/src/fs_watcher.rs
+++ b/crates/fs/src/fs_watcher.rs
@@ -1,3 +1,4 @@
+use gpui::{BackgroundExecutor, Task};
 use notify::{Event, EventKind};
 use parking_lot::Mutex;
 use std::{
@@ -19,29 +20,66 @@ pub enum WatcherMode {
 }
 
 pub struct FsWatcher {
+    executor: BackgroundExecutor,
     tx: async_channel::Sender<()>,
     pending_path_events: Arc<Mutex<Vec<PathEvent>>>,
-    registrations: Mutex<BTreeMap<Arc<std::path::Path>, WatcherRegistrationId>>,
+    registrations: Arc<Mutex<BTreeMap<Arc<std::path::Path>, FsWatcherRegistration>>>,
+    pending_registrations: Arc<Mutex<HashMap<Arc<std::path::Path>, Task<()>>>>,
+}
+
+#[derive(Clone, Copy)]
+struct FsWatcherRegistration {
+    id: WatcherRegistrationId,
     mode: WatcherMode,
 }
 
 impl FsWatcher {
     pub fn new(
+        executor: BackgroundExecutor,
         tx: async_channel::Sender<()>,
         pending_path_events: Arc<Mutex<Vec<PathEvent>>>,
-        mode: WatcherMode,
     ) -> Self {
         Self {
+            executor,
             tx,
             pending_path_events,
             registrations: Default::default(),
-            mode,
+            pending_registrations: Default::default(),
         }
     }
+
+    fn add_existing_path(&self, path: Arc<Path>) -> anyhow::Result<()> {
+        let registration_path = path.clone();
+        let registration =
+            register_existing_path(path, self.tx.clone(), self.pending_path_events.clone())?;
+        self.registrations
+            .lock()
+            .insert(registration_path, registration);
+        Ok(())
+    }
+
+    fn add_pending_path(&self, path: Arc<Path>) {
+        let mut pending_registrations = self.pending_registrations.lock();
+        if pending_registrations.contains_key(path.as_ref()) {
+            return;
+        }
+
+        let task = self.executor.spawn(poll_path_until_created(
+            self.executor.clone(),
+            path.clone(),
+            self.tx.clone(),
+            self.pending_path_events.clone(),
+            self.registrations.clone(),
+            self.pending_registrations.clone(),
+        ));
+        pending_registrations.insert(path, task);
+    }
 }
 
 impl Drop for FsWatcher {
     fn drop(&mut self) {
+        self.pending_registrations.lock().clear();
+
         let mut registrations = BTreeMap::new();
         {
             let old = &mut self.registrations.lock();
@@ -50,7 +88,7 @@ impl Drop for FsWatcher {
 
         let global_watcher = global_watcher();
         for (_, registration) in registrations {
-            global_watcher.remove(registration);
+            global_watcher.remove(registration.id);
         }
     }
 }
@@ -58,59 +96,252 @@ impl Drop for FsWatcher {
 impl Watcher for FsWatcher {
     fn add(&self, path: &std::path::Path) -> anyhow::Result<()> {
         log::trace!("watcher add: {path:?}");
-        let tx = self.tx.clone();
-        let pending_path_events = self.pending_path_events.clone();
 
-        if (self.mode == WatcherMode::Poll || cfg!(any(target_os = "windows", target_os = "macos")))
-            && let Some((watched_path, _)) = self
-                .registrations
-                .lock()
-                .range::<std::path::Path, _>((
-                    std::ops::Bound::Unbounded,
-                    std::ops::Bound::Included(path),
-                ))
-                .next_back()
-            && path.starts_with(watched_path.as_ref())
-        {
-            log::trace!(
-                "path to watch is covered by existing registration: {path:?}, {watched_path:?}"
-            );
+        let (path_is_covered_by_recursive_registration, path_is_already_watched) = {
+            let registrations = self.registrations.lock();
+            (
+                path.ancestors().skip(1).any(|ancestor| {
+                    registrations.get(ancestor).is_some_and(|registration| {
+                        registration.mode == WatcherMode::Poll
+                            || cfg!(any(target_os = "windows", target_os = "macos"))
+                    })
+                }),
+                registrations.contains_key(path),
+            )
+        };
+
+        if path_is_covered_by_recursive_registration {
+            log::trace!("path to watch is covered by existing registration: {path:?}");
             return Ok(());
         }
 
-        if self.registrations.lock().contains_key(path) {
+        if path_is_already_watched {
             log::trace!("path to watch is already watched: {path:?}");
             return Ok(());
         }
 
-        let root_path = SanitizedPath::new_arc(path);
+        if self.pending_registrations.lock().contains_key(path) {
+            log::trace!("path to watch is already pending: {path:?}");
+            return Ok(());
+        }
+
         let path: Arc<std::path::Path> = path.into();
+        if std::fs::symlink_metadata(path.as_ref()).is_err() {
+            self.add_pending_path(path);
+            return Ok(());
+        }
 
-        let registration_path = path.clone();
-        let registration_id =
-            global_watcher().add(path.clone(), self.mode, move |event: &notify::Event| {
-                log::trace!("watcher received event: {event:?}");
-                push_notify_event(&tx, &pending_path_events, &root_path, path.as_ref(), event);
-            })?;
-
-        self.registrations
-            .lock()
-            .insert(registration_path, registration_id);
-
-        Ok(())
+        self.add_existing_path(path)
     }
 
     fn remove(&self, path: &std::path::Path) -> anyhow::Result<()> {
         log::trace!("remove watched path: {path:?}");
+        self.pending_registrations.lock().remove(path);
+
         let Some(registration) = self.registrations.lock().remove(path) else {
             return Ok(());
         };
 
-        global_watcher().remove(registration);
+        global_watcher().remove(registration.id);
         Ok(())
     }
 }
 
+/// Detect whether a path requires polling instead of native file watching.
+///
+/// Returns `true` for filesystem types where inotify/FSEvents/ReadDirectoryChanges
+/// silently fail to deliver events: 9P (WSL drvfs), NFS, CIFS/SMB, FUSE (sshfs), etc.
+///
+/// Can be overridden with the `ZED_FILE_WATCHER_MODE` environment variable:
+/// - `native` — always use native OS watcher
+/// - `poll` — always use polling
+/// - `auto` (default) — auto-detect based on filesystem type
+pub fn requires_poll_watcher(path: &Path) -> bool {
+    match std::env::var("ZED_FILE_WATCHER_MODE")
+        .as_deref()
+        .unwrap_or("auto")
+    {
+        "native" => return false,
+        "poll" => return true,
+        _ => {}
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+        return detect_requires_poll_watcher_linux(path);
+    }
+
+    #[cfg(not(target_os = "linux"))]
+    {
+        let _ = path;
+        false
+    }
+}
+
+fn register_existing_path(
+    path: Arc<Path>,
+    tx: async_channel::Sender<()>,
+    pending_path_events: Arc<Mutex<Vec<PathEvent>>>,
+) -> anyhow::Result<FsWatcherRegistration> {
+    let mode = if requires_poll_watcher(path.as_ref()) {
+        log::info!(
+            "Using poll watcher ({}ms interval) for {}",
+            poll_interval().as_millis(),
+            path.display()
+        );
+        telemetry::event!("fs_watcher_poll", path = path.display().to_string());
+        WatcherMode::Poll
+    } else {
+        WatcherMode::Native
+    };
+    let root_path = SanitizedPath::new_arc(path.as_ref());
+    let path_for_callback = path.clone();
+    let registration_id = global_watcher().add(path, mode, move |event: &notify::Event| {
+        log::trace!("watcher received event: {event:?}");
+        push_notify_event(
+            &tx,
+            &pending_path_events,
+            &root_path,
+            path_for_callback.as_ref(),
+            event,
+        );
+    })?;
+    Ok(FsWatcherRegistration {
+        id: registration_id,
+        mode,
+    })
+}
+
+#[cfg(target_os = "linux")]
+fn detect_requires_poll_watcher_linux(path: &Path) -> bool {
+    use std::ffi::CString;
+    use std::os::unix::ffi::OsStrExt;
+
+    let c_path = match CString::new(path.as_os_str().as_bytes()) {
+        Ok(p) => p,
+        Err(_) => return false,
+    };
+
+    let mut stat: libc::statfs = unsafe { std::mem::zeroed() };
+    if unsafe { libc::statfs(c_path.as_ptr(), &mut stat) } != 0 {
+        return false;
+    }
+
+    const V9FS_MAGIC: u64 = 0x0102_1997;
+    const NFS_SUPER_MAGIC: u64 = 0x0000_6969;
+    const CIFS_MAGIC: u64 = 0xFF53_4D42;
+    const SMB_SUPER_MAGIC: u64 = 0x0000_517B;
+    const SMB2_MAGIC: u64 = 0xFE53_4D42;
+    const FUSE_SUPER_MAGIC: u64 = 0x6573_5546;
+
+    let fs_type = (stat.f_type as u64) & 0xFFFF_FFFF;
+    if fs_type == V9FS_MAGIC
+        || fs_type == NFS_SUPER_MAGIC
+        || fs_type == CIFS_MAGIC
+        || fs_type == SMB_SUPER_MAGIC
+        || fs_type == SMB2_MAGIC
+        || fs_type == FUSE_SUPER_MAGIC
+    {
+        log::info!(
+            "Detected network/virtual filesystem (type 0x{:x}) at {}, using poll watcher",
+            fs_type,
+            path.display()
+        );
+        return true;
+    }
+
+    if is_wsl_drvfs_path(path) {
+        log::info!(
+            "Detected WSL drvfs mount at {}, using poll watcher",
+            path.display()
+        );
+        return true;
+    }
+
+    false
+}
+
+#[cfg(target_os = "linux")]
+fn is_wsl_drvfs_path(path: &Path) -> bool {
+    if std::env::var_os("WSL_DISTRO_NAME").is_none() {
+        if let Ok(version) = std::fs::read_to_string("/proc/version") {
+            let version = version.to_lowercase();
+            if !version.contains("microsoft") && !version.contains("wsl") {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    }
+
+    let Some(path) = path.to_str() else {
+        return false;
+    };
+    if !path.starts_with("/mnt/") || path.len() < 6 {
+        return false;
+    }
+    let after_mnt = &path[5..];
+    after_mnt.starts_with(|c: char| c.is_ascii_alphabetic())
+        && (after_mnt.len() == 1 || after_mnt.as_bytes()[1] == b'/')
+}
+
+async fn poll_path_until_created(
+    executor: BackgroundExecutor,
+    path: Arc<Path>,
+    tx: async_channel::Sender<()>,
+    pending_path_events: Arc<Mutex<Vec<PathEvent>>>,
+    registrations: Arc<Mutex<BTreeMap<Arc<Path>, FsWatcherRegistration>>>,
+    pending_registrations: Arc<Mutex<HashMap<Arc<Path>, Task<()>>>>,
+) {
+    loop {
+        executor.timer(poll_interval()).await;
+
+        if !pending_registrations.lock().contains_key(path.as_ref()) {
+            return;
+        }
+
+        if smol::fs::symlink_metadata(path.as_ref()).await.is_err() {
+            continue;
+        }
+
+        if registrations.lock().contains_key(path.as_ref()) {
+            pending_registrations.lock().remove(path.as_ref());
+            return;
+        }
+
+        match register_existing_path(path.clone(), tx.clone(), pending_path_events.clone()) {
+            Ok(registration) => {
+                {
+                    let mut pending_registrations = pending_registrations.lock();
+                    if pending_registrations.remove(path.as_ref()).is_none() {
+                        global_watcher().remove(registration.id);
+                        return;
+                    }
+                    registrations.lock().insert(path.clone(), registration);
+                }
+                enqueue_path_events(
+                    &tx,
+                    &pending_path_events,
+                    vec![
+                        PathEvent {
+                            path: path.to_path_buf(),
+                            kind: Some(PathEventKind::Created),
+                        },
+                        PathEvent {
+                            path: path.to_path_buf(),
+                            kind: Some(PathEventKind::Rescan),
+                        },
+                    ],
+                );
+                return;
+            }
+            Err(error) => {
+                log::warn!("failed to watch newly-created path {path:?}: {error}; retrying");
+            }
+        }
+    }
+}
+
 fn enqueue_path_events(
     tx: &smol::channel::Sender<()>,
     pending_path_events: &Arc<Mutex<Vec<PathEvent>>>,
@@ -417,9 +648,10 @@ fn path_already_covered(
     mode: WatcherMode,
 ) -> bool {
     (mode == WatcherMode::Poll || cfg!(any(target_os = "windows", target_os = "macos")))
-        && path_registrations
-            .keys()
-            .any(|existing| path.starts_with(existing.as_ref()) && path != existing.as_ref())
+        && path
+            .ancestors()
+            .skip(1)
+            .any(|ancestor| path_registrations.contains_key(ancestor))
 }
 
 static POLL_INTERVAL: LazyLock<Duration> = LazyLock::new(|| {

From 8dff89c8d145deea1149af91f6414b869c5c2ef6 Mon Sep 17 00:00:00 2001
From: Richard Feldman <richard@zed.dev>
Date: Tue, 19 May 2026 15:04:48 -0400
Subject: [PATCH 036/105] Fix Gemini schema conversion dropping anyOf and
 nullability (#57160)

Follow-up to #49292:

- **Bug fix in `push_any_of_constraint`**: when both an `anyOf` and a
non-empty `allOf` were already present at the same level, the existing
`anyOf` was silently dropped. Now it's always preserved.
- **Canonical OpenAPI nullability**: collapse `{nullable: true}`-only
entries out of `anyOf` onto the parent so `anyOf: [{type: "string"},
{type: "null"}]` becomes `{type: "string", nullable: true}` (the form
Gemini actually expects) instead of `anyOf: [{type: "string"},
{nullable: true}]`.
- **Compile-time path consistency**: route `ToJsonSchemaSubsetTransform`
through the same `convert_null_in_types_to_nullable` helper so
Rust-defined tools using `Option<T>` also keep nullability on Gemini,
instead of silently truncating to the non-null type.
- Drop an unnecessary clone in `push_any_of_constraint` and simplify
`convert_types_to_any_of_defs`.
- Add a small `obj()` test helper and a regression test for the `anyOf +
allOf + multi-type` case.

Release Notes:

- Fixed `Option<T>` tool parameters being sent to Gemini without their
nullability, and fixed tool schemas with `anyOf` + `allOf` losing
constraints during the OpenAPI 3.0 conversion

Co-authored-by: Daniel Strobusch <1438302+dastrobu@users.noreply.github.com>
---
 crates/language_model_core/src/tool_schema.rs | 363 ++++++++++--------
 1 file changed, 209 insertions(+), 154 deletions(-)

diff --git a/crates/language_model_core/src/tool_schema.rs b/crates/language_model_core/src/tool_schema.rs
index 729d625939c..13e6e665244 100644
--- a/crates/language_model_core/src/tool_schema.rs
+++ b/crates/language_model_core/src/tool_schema.rs
@@ -39,21 +39,31 @@ struct ToJsonSchemaSubsetTransform;
 
 impl Transform for ToJsonSchemaSubsetTransform {
     fn transform(&mut self, schema: &mut Schema) {
-        // Ensure that the type field is not an array, this happens when we use
-        // Option<T>, the type will be [T, "null"].
-        if let Some(type_field) = schema.get_mut("type")
-            && let Some(types) = type_field.as_array()
-            && let Some(first_type) = types.first()
-        {
-            *type_field = first_type.clone();
-        }
+        if let Some(obj) = schema.as_object_mut() {
+            // `Option<T>` produces `type: [T, "null"]`. Convert to OpenAPI 3.0's
+            // `nullable: true` so nullability isn't silently dropped.
+            convert_null_in_types_to_nullable(obj);
 
-        // oneOf is not supported, use anyOf instead
-        if let Some(one_of) = schema.remove("oneOf") {
-            schema.insert("anyOf".to_string(), one_of);
+            // Any remaining multi-type array (uncommon in Rust-generated schemas)
+            // is collapsed to its first entry to keep this schema subset-compatible.
+            if let Some(type_field) = obj.get_mut("type")
+                && let Some(types) = type_field.as_array()
+                && let Some(first_type) = types.first().cloned()
+            {
+                *type_field = first_type;
+            }
+
+            // oneOf is not supported, use anyOf instead
+            if let Some(one_of) = obj.remove("oneOf") {
+                obj.insert("anyOf".to_string(), one_of);
+            }
         }
 
         transform_subschemas(self, schema);
+
+        if let Some(obj) = schema.as_object_mut() {
+            collapse_nullable_only_any_of(obj);
+        }
     }
 }
 
@@ -126,14 +136,16 @@ fn adapt_to_json_schema_subset(json: &mut Value) -> Result<()> {
         convert_null_in_types_to_nullable(obj);
         convert_types_to_any_of_defs(obj);
 
-        // Ensure that the type field is not an array. This can happen with MCP tool
-        // schemas that use multiple types (e.g. `["string", "number"]` or `["string", "null"]`).
+        // After the conversions above, `type` should only ever still be an array
+        // if a malformed input had a single-element type array (e.g. `["string"]`).
+        // Collapse it to a single value so downstream consumers see a scalar.
         if let Some(type_value) = obj.get_mut("type")
             && let Some(types) = type_value.as_array()
             && let Some(first_type) = types.first().cloned()
         {
             *type_value = first_type;
         }
+
         if matches!(obj.get("description"), Some(Value::String(_)))
             && !obj.contains_key("type")
             && !(obj.contains_key("anyOf")
@@ -156,6 +168,11 @@ fn adapt_to_json_schema_subset(json: &mut Value) -> Result<()> {
                 adapt_to_json_schema_subset(value)?;
             }
         }
+
+        // Children may have been rewritten from `{"type": "null"}` into
+        // `{"nullable": true}`. Fold those into the parent so the result matches
+        // OpenAPI 3.0's convention of `nullable: true` as a sibling of `type`.
+        collapse_nullable_only_any_of(obj);
     } else if let Value::Array(arr) = json {
         for item in arr.iter_mut() {
             adapt_to_json_schema_subset(item)?;
@@ -200,30 +217,30 @@ fn convert_null_in_types_to_nullable(obj: &mut Map<String, Value>) {
 }
 
 fn convert_types_to_any_of_defs(obj: &mut Map<String, Value>) {
-    if let Some(type_entry) = obj.get_mut("type") {
-        if let Some(types) = type_entry.as_array_mut() {
-            if types.len() > 1 {
-                let remaining_types = std::mem::take(types);
-                let mut any_of_schemas = Vec::new();
-                for t in remaining_types {
-                    any_of_schemas.push(json!({"type": t}));
-                }
-                obj.remove("type");
-                push_any_of_constraint(obj, Value::Array(any_of_schemas));
-            }
-        }
+    let is_multi_type = obj
+        .get("type")
+        .and_then(|v| v.as_array())
+        .is_some_and(|types| types.len() > 1);
+    if !is_multi_type {
+        return;
     }
+
+    let Some(Value::Array(types)) = obj.remove("type") else {
+        return;
+    };
+    let any_of_schemas = types.into_iter().map(|t| json!({"type": t})).collect();
+    push_any_of_constraint(obj, Value::Array(any_of_schemas));
 }
 
 fn push_any_of_constraint(obj: &mut Map<String, Value>, any_of_schemas: Value) {
     if let Some(existing_any_of) = obj.remove("anyOf") {
-        let mut all_of = obj
-            .remove("allOf")
-            .and_then(|v| v.as_array().cloned())
-            .unwrap_or_default();
-        if all_of.is_empty() {
-            all_of.push(json!({"anyOf": existing_any_of}));
-        }
+        let mut all_of = match obj.remove("allOf") {
+            Some(Value::Array(arr)) => arr,
+            _ => Vec::new(),
+        };
+        // Always preserve the pre-existing `anyOf` — earlier this push was
+        // skipped when `allOf` was non-empty, which silently dropped it.
+        all_of.push(json!({"anyOf": existing_any_of}));
         all_of.push(json!({"anyOf": any_of_schemas}));
         obj.insert("allOf".to_string(), Value::Array(all_of));
     } else if let Some(all_of) = obj.get_mut("allOf").and_then(|v| v.as_array_mut()) {
@@ -233,189 +250,187 @@ fn push_any_of_constraint(obj: &mut Map<String, Value>, any_of_schemas: Value) {
     }
 }
 
+/// Folds `{nullable: true}`-only entries out of an `anyOf` array and onto the
+/// parent object. This matches OpenAPI 3.0 semantics, where nullability is
+/// expressed as a sibling of `type` rather than a separate variant.
+fn collapse_nullable_only_any_of(obj: &mut Map<String, Value>) {
+    let Some(Value::Array(mut any_of)) = obj.remove("anyOf") else {
+        return;
+    };
+
+    let mut found_nullable_only = false;
+    any_of.retain(|entry| {
+        let is_nullable_only = entry
+            .as_object()
+            .is_some_and(|m| m.len() == 1 && matches!(m.get("nullable"), Some(Value::Bool(true))));
+        if is_nullable_only {
+            found_nullable_only = true;
+            false
+        } else {
+            true
+        }
+    });
+
+    if !found_nullable_only {
+        obj.insert("anyOf".to_string(), Value::Array(any_of));
+        return;
+    }
+
+    obj.insert("nullable".to_string(), Value::Bool(true));
+
+    if any_of.is_empty() {
+        return;
+    }
+
+    // If a single variant remains and its keys don't collide with the parent's
+    // existing keys, inline it. `anyOf` with a single entry is equivalent to
+    // just that entry, and inlining produces the canonical OpenAPI form
+    // (e.g. `{type: "string", nullable: true}`).
+    if any_of.len() == 1
+        && let Value::Object(entry_obj) = &any_of[0]
+        && entry_obj.keys().all(|k| !obj.contains_key(k))
+    {
+        let entry = any_of.remove(0);
+        if let Value::Object(entry_obj) = entry {
+            for (k, v) in entry_obj {
+                obj.insert(k, v);
+            }
+        }
+        return;
+    }
+
+    obj.insert("anyOf".to_string(), Value::Array(any_of));
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
     use serde_json::json;
 
+    fn obj(value: Value) -> Map<String, Value> {
+        match value {
+            Value::Object(map) => map,
+            other => panic!("expected JSON object, got {other}"),
+        }
+    }
+
     #[test]
     fn test_convert_null_in_types_to_nullable() {
         // ["string", "null"] -> "string", nullable: true
-        let mut obj = json!({"type": ["string", "null"]})
-            .as_object_mut()
-            .unwrap()
-            .to_owned();
-        convert_null_in_types_to_nullable(&mut obj);
-        assert_eq!(
-            obj,
-            json!({"type": "string", "nullable": true})
-                .as_object()
-                .unwrap()
-                .to_owned()
-        );
+        let mut o = obj(json!({"type": ["string", "null"]}));
+        convert_null_in_types_to_nullable(&mut o);
+        assert_eq!(o, obj(json!({"type": "string", "nullable": true})));
 
         // "null" -> nullable: true
-        let mut obj = json!({"type": "null"}).as_object_mut().unwrap().to_owned();
-        convert_null_in_types_to_nullable(&mut obj);
-        assert_eq!(
-            obj,
-            json!({"nullable": true}).as_object().unwrap().to_owned()
-        );
+        let mut o = obj(json!({"type": "null"}));
+        convert_null_in_types_to_nullable(&mut o);
+        assert_eq!(o, obj(json!({"nullable": true})));
 
         // ["string", "number", "null"] -> ["string", "number"], nullable: true (anyOf handled elsewhere)
-        let mut obj = json!({"type": ["string", "number", "null"]})
-            .as_object_mut()
-            .unwrap()
-            .to_owned();
-        convert_null_in_types_to_nullable(&mut obj);
+        let mut o = obj(json!({"type": ["string", "number", "null"]}));
+        convert_null_in_types_to_nullable(&mut o);
         assert_eq!(
-            obj,
-            json!({"type": ["string", "number"], "nullable": true})
-                .as_object()
-                .unwrap()
-                .to_owned()
+            o,
+            obj(json!({"type": ["string", "number"], "nullable": true}))
         );
 
         // "string" (no change, not nullable)
-        let mut obj = json!({"type": "string"})
-            .as_object_mut()
-            .unwrap()
-            .to_owned();
-        convert_null_in_types_to_nullable(&mut obj);
-        assert_eq!(
-            obj,
-            json!({"type": "string"}).as_object().unwrap().to_owned()
-        );
+        let mut o = obj(json!({"type": "string"}));
+        convert_null_in_types_to_nullable(&mut o);
+        assert_eq!(o, obj(json!({"type": "string"})));
 
         // ["string", "number"] (no change, not nullable)
-        let mut obj = json!({"type": ["string", "number"]})
-            .as_object_mut()
-            .unwrap()
-            .to_owned();
-        convert_null_in_types_to_nullable(&mut obj);
-        assert_eq!(
-            obj,
-            json!({"type": ["string", "number"]})
-                .as_object()
-                .unwrap()
-                .to_owned()
-        );
+        let mut o = obj(json!({"type": ["string", "number"]}));
+        convert_null_in_types_to_nullable(&mut o);
+        assert_eq!(o, obj(json!({"type": ["string", "number"]})));
 
         // object with other properties, ["boolean", "null"]
-        let mut obj = json!({
+        let mut o = obj(json!({
             "description": "A test field",
             "type": ["boolean", "null"]
-        })
-        .as_object_mut()
-        .unwrap()
-        .to_owned();
-        convert_null_in_types_to_nullable(&mut obj);
+        }));
+        convert_null_in_types_to_nullable(&mut o);
         assert_eq!(
-            obj,
-            json!({
+            o,
+            obj(json!({
                 "description": "A test field",
                 "type": "boolean",
                 "nullable": true
-            })
-            .as_object()
-            .unwrap()
-            .to_owned()
+            }))
         );
     }
 
     #[test]
     fn test_convert_types_to_any_of_defs() {
         // ["string", "number"] -> anyOf with string and number
-        let mut obj = json!({"type": ["string", "number"]})
-            .as_object_mut()
-            .unwrap()
-            .to_owned();
-        convert_types_to_any_of_defs(&mut obj);
+        let mut o = obj(json!({"type": ["string", "number"]}));
+        convert_types_to_any_of_defs(&mut o);
         assert_eq!(
-            obj,
-            json!({
+            o,
+            obj(json!({
                 "anyOf": [
                     {"type": "string"},
                     {"type": "number"}
                 ]
-            })
-            .as_object()
-            .unwrap()
-            .to_owned()
+            }))
         );
 
         // "string" (no change)
-        let mut obj = json!({"type": "string"})
-            .as_object_mut()
-            .unwrap()
-            .to_owned();
-        convert_types_to_any_of_defs(&mut obj);
-        assert_eq!(
-            obj,
-            json!({"type": "string"}).as_object().unwrap().to_owned()
-        );
+        let mut o = obj(json!({"type": "string"}));
+        convert_types_to_any_of_defs(&mut o);
+        assert_eq!(o, obj(json!({"type": "string"})));
+
+        // single-element array (no change, fallback in caller collapses it)
+        let mut o = obj(json!({"type": ["string"]}));
+        convert_types_to_any_of_defs(&mut o);
+        assert_eq!(o, obj(json!({"type": ["string"]})));
 
         // object with other properties, ["string", "number"]
-        let mut obj = json!({
+        let mut o = obj(json!({
             "description": "A test field",
             "type": ["string", "number"]
-        })
-        .as_object_mut()
-        .unwrap()
-        .to_owned();
-        convert_types_to_any_of_defs(&mut obj);
+        }));
+        convert_types_to_any_of_defs(&mut o);
         assert_eq!(
-            obj,
-            json!({
+            o,
+            obj(json!({
                 "description": "A test field",
                 "anyOf": [
                     {"type": "string"},
                     {"type": "number"}
                 ]
-            })
-            .as_object()
-            .unwrap()
-            .to_owned()
+            }))
         );
 
         // anyOf already present (no change)
-        let mut obj = json!({
+        let mut o = obj(json!({
             "anyOf": [
                 {"type": "string"},
                 {"type": "number"}
             ]
-        })
-        .as_object_mut()
-        .unwrap()
-        .to_owned();
-        convert_types_to_any_of_defs(&mut obj);
+        }));
+        convert_types_to_any_of_defs(&mut o);
         assert_eq!(
-            obj,
-            json!({
+            o,
+            obj(json!({
                 "anyOf": [
                     {"type": "string"},
                     {"type": "number"}
                 ]
-            })
-            .as_object()
-            .unwrap()
-            .to_owned()
+            }))
         );
 
         // both type array and anyOf present
-        let mut obj = json!({
+        let mut o = obj(json!({
             "type": ["string", "number"],
             "anyOf": [
                 {"format": "email"}
             ]
-        })
-        .as_object_mut()
-        .unwrap()
-        .to_owned();
-        convert_types_to_any_of_defs(&mut obj);
+        }));
+        convert_types_to_any_of_defs(&mut o);
         assert_eq!(
-            obj,
-            json!({
+            o,
+            obj(json!({
                 "allOf": [
                     {
                         "anyOf": [
@@ -429,10 +444,26 @@ mod tests {
                         ]
                     }
                 ]
-            })
-            .as_object()
-            .unwrap()
-            .to_owned()
+            }))
+        );
+
+        // type array + anyOf + pre-existing allOf: pre-existing anyOf must not
+        // be silently dropped just because allOf is non-empty.
+        let mut o = obj(json!({
+            "type": ["string", "number"],
+            "anyOf": [{"minLength": 5}],
+            "allOf": [{"maxLength": 100}]
+        }));
+        convert_types_to_any_of_defs(&mut o);
+        assert_eq!(
+            o,
+            obj(json!({
+                "allOf": [
+                    {"maxLength": 100},
+                    {"anyOf": [{"minLength": 5}]},
+                    {"anyOf": [{"type": "string"}, {"type": "number"}]}
+                ]
+            }))
         );
     }
 
@@ -544,12 +575,38 @@ mod tests {
 
         adapt_to_json_schema_subset(&mut json).unwrap();
 
+        // Should collapse to the canonical OpenAPI 3.0 form: `nullable: true`
+        // as a sibling of `type`, rather than a separate anyOf variant.
         assert_eq!(
             json,
             json!({
+                "type": "string",
+                "nullable": true
+            })
+        );
+    }
+
+    #[test]
+    fn test_transform_null_in_any_of_with_multiple_non_null_variants() {
+        let mut json = json!({
+            "anyOf": [
+                { "type": "string" },
+                { "type": "number" },
+                { "type": "null" }
+            ]
+        });
+
+        adapt_to_json_schema_subset(&mut json).unwrap();
+
+        // When more than one non-null variant remains, keep the anyOf and just
+        // hoist `nullable: true` onto the parent.
+        assert_eq!(
+            json,
+            json!({
+                "nullable": true,
                 "anyOf": [
                     { "type": "string" },
-                    { "nullable": true }
+                    { "type": "number" }
                 ]
             })
         );
@@ -643,10 +700,8 @@ mod tests {
                 "type": "object",
                 "properties": {
                     "nested": {
-                        "anyOf": [
-                            { "type": "string" },
-                            { "nullable": true }
-                        ],
+                        "type": "string",
+                        "nullable": true
                     }
                 }
             })

From 69effe73d9520e924cfb8be80660f1a0ab796752 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mar=C3=ADa=20Craig?= <maria@zed.dev>
Date: Tue, 19 May 2026 16:21:41 -0300
Subject: [PATCH 037/105] docs: Document Terminal Threads feature (#56679)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds documentation for the Terminal Threads feature — the ability to
open interactive terminals in the Agent Panel alongside threads.

## Changes

- **`agent-panel.md`**: Adds a new `## Terminals` section covering how
to open terminals, terminal titles, bell notifications, and closing.
Also adds a Terminal bullet to the `+` menu description in "Creating New
Threads".
- **`parallel-agents.md`**: Updates the page title, description, and
opening paragraph to include terminals alongside threads. Adds a note in
the Threads Sidebar section that terminals appear there too.

Release Notes:

- N/A

---------

Co-authored-by: Zed Zippy <234243425+zed-zippy[bot]@users.noreply.github.com>
Co-authored-by: Ben Brandt <benjamin.j.brandt@gmail.com>
---
 docs/src/ai/agent-panel.md     | 54 ++++++++++++++++++++++++++++++++++
 docs/src/ai/overview.md        |  2 +-
 docs/src/ai/parallel-agents.md |  6 ++--
 3 files changed, 59 insertions(+), 3 deletions(-)

diff --git a/docs/src/ai/agent-panel.md b/docs/src/ai/agent-panel.md
index 0187d3a0b24..fe71ee914cb 100644
--- a/docs/src/ai/agent-panel.md
+++ b/docs/src/ai/agent-panel.md
@@ -40,6 +40,7 @@ From the "New Thread…" menu you can:
 
 - Pick **Zed Agent** or any installed [external agent](./external-agents.md) to start a new thread with that agent.
 - Choose **New From Summary** to start a fresh Zed Agent thread seeded with a summary of the current conversation — useful for compacting long threads as you approach the context window limit.
+- Choose **Terminal** to open a terminal thread directly in the Agent Panel — see [Terminal Threads](#terminal-threads) for details.
 
 {#action agent::NewExternalAgentThread} creates a new thread with the specified external agent id.
 
@@ -123,6 +124,59 @@ Edit diffs also appear in singleton buffers.
 If your active tab had edits made by the AI, you'll see diffs with the same accept/reject controls as in the multi-buffer.
 You can turn this off, though, through the `agent.single_file_review` setting.
 
+## Terminal Threads {#terminal-threads}
+
+The Agent Panel can host terminal threads alongside your agent threads. Each terminal thread appears as its own entry in the [Threads Sidebar](./parallel-agents.md#threads-sidebar) with a terminal icon, letting you switch between conversations and shell sessions from the same list.
+
+External agents like Claude Agent and Codex can also run as terminal threads. Some support terminal signals — such as bell notifications or title updates — that Zed uses to show useful context in the sidebar.
+
+### Opening a Terminal Thread {#opening-a-terminal-thread}
+
+Open the menu using the agent selector button on the left (in the empty state) or the `+` icon in the top-right of the panel toolbar, and choose **Terminal**. The terminal thread opens in the panel body, just like switching to a thread. You can open as many as you like — each gets its own sidebar entry.
+
+### Terminal Thread Titles {#terminal-thread-titles}
+
+The terminal title in the toolbar updates automatically to reflect the running shell or process. You can also set a custom name by clicking the title or the pencil icon that appears on hover.
+
+### Notifications {#terminal-thread-notifications}
+
+When a terminal produces a bell character while not in focus, Zed notifies you the same way it does when an agent finishes — with a visual pop-up and an optional sound. Clicking the notification brings the terminal into focus and clears the indicator. The same `agent.notify_when_agent_waiting` and `agent.play_sound_when_agent_done` settings apply.
+
+### Closing Terminal Threads {#closing-terminal-threads}
+
+Unlike agent threads, terminal threads are closed rather than archived — they don't go to Thread History. To close one, hover over it in the Threads Sidebar and click the **×** button, or select it and press {#kb agent::ArchiveSelectedThread}.
+
+### Claude Code Notifications {#claude-code-notifications}
+
+Claude Code can ring the terminal bell when it finishes a task or pauses for permission. To enable this, set `preferredNotifChannel` to `"terminal_bell"` in your Claude Code user settings:
+
+```json
+{
+  "preferredNotifChannel": "terminal_bell"
+}
+```
+
+You can also set this from within Claude Code by running `/config`, selecting `Local Notifications`, and choosing `Terminal Bell`.
+
+> If you run Claude Code inside tmux, bell notifications may not reach the outer terminal unless passthrough is enabled. Add this to `~/.tmux.conf`:
+>
+> ```
+> set -g allow-passthrough on
+> ```
+
+For more, see the [Claude Code documentation](https://code.claude.com/docs/en/terminal-config).
+
+### Codex Terminal Titles {#codex-terminal-titles}
+
+Codex can update the terminal title as it works, which Zed uses to show useful context for Codex terminal threads in the sidebar — such as the project, current status, branch, model, or task progress.
+
+To configure this from within Codex, run `/title` and use the picker to choose which fields appear and in what order. Codex saves the selection to `tui.terminal_title` in `~/.codex/config.toml`. You can also edit it directly:
+
+```toml
+[tui]
+terminal_title = ["spinner", "project-name", "run-state", "thread-title"]
+```
+
 ## Adding Context {#adding-context}
 
 The agent can search your codebase to find relevant context, but providing it explicitly improves response quality and reduces latency.
diff --git a/docs/src/ai/overview.md b/docs/src/ai/overview.md
index 0859d47c127..413b67ba595 100644
--- a/docs/src/ai/overview.md
+++ b/docs/src/ai/overview.md
@@ -18,7 +18,7 @@ Zed's AI features run inside a native, GPU-accelerated application built in Rust
 
 ## Agentic editing
 
-The [Threads Sidebar](./parallel-agents.md#threads-sidebar) is where you organize agent work. Start a thread, give it a task, and the agent reads, edits, and runs code in your project. You can run multiple threads at once, each using a different agent and working against different projects. See [Tools](./tools.md) for the capabilities available to Zed's built-in agent.
+The [Threads Sidebar](./parallel-agents.md#threads-sidebar) is where you organize agent work. Start a thread, give it a task, and the agent reads, edits, and runs code in your project. You can also open terminal threads directly in the sidebar alongside your agent threads. Run multiple agent threads and terminal threads at once, each using a different agent and working against different projects. See [Tools](./tools.md) for the capabilities available to Zed's built-in agent.
 
 The [Agent Panel](./agent-panel.md) is the conversation view for the active thread. Use it to send prompts, review changes, add context, and interact with the agent as it works.
 
diff --git a/docs/src/ai/parallel-agents.md b/docs/src/ai/parallel-agents.md
index 17d61528eea..6c8fccea8d5 100644
--- a/docs/src/ai/parallel-agents.md
+++ b/docs/src/ai/parallel-agents.md
@@ -1,11 +1,11 @@
 ---
 title: Parallel Agents - Zed
-description: Run multiple agent threads concurrently using the Threads Sidebar, manage them across projects, and isolate work using Git worktrees.
+description: Run multiple agent threads and terminal threads concurrently using the Threads Sidebar, manage them across projects, and isolate work using Git worktrees.
 ---
 
 # Parallel Agents
 
-Parallel Agents lets you run multiple agent threads at once, each working independently with its own agent, context window, and conversation history. The Threads Sidebar is where you start, manage, and switch between them.
+Parallel Agents lets you run multiple agent threads and terminal threads at once from the Threads Sidebar. Each thread works independently with its own agent, context window, and conversation history. Terminal threads appear alongside agent threads in the same sidebar, so you can switch between them without leaving the Agent Panel.
 
 Open the Threads Sidebar with {#kb multi_workspace::ToggleWorkspaceSidebar}.
 
@@ -15,6 +15,8 @@ Open the Threads Sidebar with {#kb multi_workspace::ToggleWorkspaceSidebar}.
 
 The sidebar shows your threads grouped by project. Each project gets its own section with a header. Threads appear below with their title, status indicator, and which agent is running them. Threads running in linked Git worktrees appear under the same project as their main worktree. See [Worktree Isolation](#worktree-isolation).
 
+Terminal threads also appear as entries in the sidebar alongside agent threads, identified by a terminal icon. Click one to switch to it. See [terminal threads](./agent-panel.md#terminal-threads) for details.
+
 To focus the sidebar without toggling it, use {#kb multi_workspace::FocusWorkspaceSidebar}. To search your threads, press {#kb agents_sidebar::FocusSidebarFilter} while the sidebar is focused.
 
 ### Switching Threads {#switching-threads}

From 40d3c79f2f997ac5611975a27cc15d016ff600fe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mar=C3=ADa=20Craig?= <maria@zed.dev>
Date: Tue, 19 May 2026 17:05:13 -0300
Subject: [PATCH 038/105] Update workspace mentions in the sidebar (#54833)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replaces "workspace" labels in the sidebar with more accurate
terminology:

- "Focus Last Workspace" → "Focus Last Project"
- "Focus Workspace" → "Focus Project"
- "Close Workspace" tooltip → "Close Worktree"

Release Notes:

- N/A
---
 crates/sidebar/src/sidebar.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/sidebar/src/sidebar.rs b/crates/sidebar/src/sidebar.rs
index a86960f3fb5..7fcaf38a3f5 100644
--- a/crates/sidebar/src/sidebar.rs
+++ b/crates/sidebar/src/sidebar.rs
@@ -2276,9 +2276,9 @@ impl Sidebar {
                                             .child(Label::new("-click").color(Color::Muted));
 
                                         let label = if has_threads {
-                                            "Focus Last Workspace"
+                                            "Focus Last Project"
                                         } else {
-                                            "Focus Workspace"
+                                            "Focus Project"
                                         };
 
                                         h_flex()
@@ -2390,7 +2390,7 @@ impl Sidebar {
                                                     )
                                                     .icon_size(IconSize::Small)
                                                     .visible_on_hover(&row_group_name)
-                                                    .tooltip(Tooltip::text("Close Workspace"))
+                                                    .tooltip(Tooltip::text("Close Worktree"))
                                                     .on_click(move |_, window, cx| {
                                                         cx.stop_propagation();
                                                         window.prevent_default();

From ad042e5c9de540ec3ea61188e950a6c955f00938 Mon Sep 17 00:00:00 2001
From: Ben Kunkle <ben@zed.dev>
Date: Tue, 19 May 2026 16:14:50 -0400
Subject: [PATCH 039/105] fs: Don't opt into polling for `virtiofs` based file
 systems (#57184)

Technically we don't know if a `virtiofs` file system supports `inotify`
or not, but it seems like it's mostly used inside virtual machines
provided by:
- OrbStack (`inotify` works)
- Docker Desktop (`inotify` works)
- Lima (`inotify` works with flag)
- Colima (`inotify` works with flag)
- QEMU + virtiofs setup (`inotify` doesn't work without extra setup)

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Closes #57103

Closes FR-9

Release Notes:

- Fixed an issue where file system watching would default to the polling
backend inside of `OrbStack` VMs on MacOS
---
 crates/fs/src/fs_watcher.rs | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/crates/fs/src/fs_watcher.rs b/crates/fs/src/fs_watcher.rs
index 2c8078f1324..34758afe044 100644
--- a/crates/fs/src/fs_watcher.rs
+++ b/crates/fs/src/fs_watcher.rs
@@ -235,6 +235,10 @@ fn detect_requires_poll_watcher_linux(path: &Path) -> bool {
     const FUSE_SUPER_MAGIC: u64 = 0x6573_5546;
 
     let fs_type = (stat.f_type as u64) & 0xFFFF_FFFF;
+    if fs_type == FUSE_SUPER_MAGIC && is_virtiofs(path) {
+        return false;
+    }
+
     if fs_type == V9FS_MAGIC
         || fs_type == NFS_SUPER_MAGIC
         || fs_type == CIFS_MAGIC
@@ -261,6 +265,37 @@ fn detect_requires_poll_watcher_linux(path: &Path) -> bool {
     false
 }
 
+#[cfg(target_os = "linux")]
+fn is_virtiofs(path: &Path) -> bool {
+    let Ok(mountinfo) = std::fs::read_to_string("/proc/self/mountinfo") else {
+        return false;
+    };
+
+    let mut best_mount = None;
+    for line in mountinfo.lines() {
+        let fields = line.split(' ').collect::<Vec<_>>();
+        let Some(separator) = fields.iter().position(|field| *field == "-") else {
+            continue;
+        };
+        let (Some(mount_point), Some(fs_type)) = (fields.get(4), fields.get(separator + 1)) else {
+            continue;
+        };
+
+        let mount_point = mount_point
+            .replace("\\040", " ")
+            .replace("\\011", "\t")
+            .replace("\\012", "\n")
+            .replace("\\134", "\\");
+        if path.starts_with(&mount_point)
+            && best_mount.is_none_or(|(length, _)| mount_point.len() > length)
+        {
+            best_mount = Some((mount_point.len(), *fs_type));
+        }
+    }
+
+    best_mount.is_some_and(|(_, fs_type)| fs_type == "virtiofs" || fs_type == "fuse.virtiofs")
+}
+
 #[cfg(target_os = "linux")]
 fn is_wsl_drvfs_path(path: &Path) -> bool {
     if std::env::var_os("WSL_DISTRO_NAME").is_none() {

From a39f1d163d71493d9594c5a98722839019762216 Mon Sep 17 00:00:00 2001
From: Ben Brandt <benjamin.j.brandt@gmail.com>
Date: Tue, 19 May 2026 23:08:14 +0200
Subject: [PATCH 040/105] docs: Add more agent configuration examples (#57188)

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Release Notes:

- N/A
---
 docs/src/ai/agent-panel.md | 54 +++++++++++++++++++++++++++++++++++++-
 1 file changed, 53 insertions(+), 1 deletion(-)

diff --git a/docs/src/ai/agent-panel.md b/docs/src/ai/agent-panel.md
index fe71ee914cb..77c052d4841 100644
--- a/docs/src/ai/agent-panel.md
+++ b/docs/src/ai/agent-panel.md
@@ -148,7 +148,7 @@ Unlike agent threads, terminal threads are closed rather than archived — they
 
 ### Claude Code Notifications {#claude-code-notifications}
 
-Claude Code can ring the terminal bell when it finishes a task or pauses for permission. To enable this, set `preferredNotifChannel` to `"terminal_bell"` in your Claude Code user settings:
+Claude Code can notify you when it finishes a task or pauses for permission. To enable this, set `preferredNotifChannel` to `"terminal_bell"` in your Claude Code user settings:
 
 ```json
 {
@@ -166,6 +166,58 @@ You can also set this from within Claude Code by running `/config`, selecting `L
 
 For more, see the [Claude Code documentation](https://code.claude.com/docs/en/terminal-config).
 
+### Amp Notifications {#amp-notifications}
+
+Amp updates terminal titles automatically and can also notify you when it needs your attention. To enable notifications in Zed terminal threads, add `AMP_FORCE_BEL=1` to your terminal environment settings:
+
+```json [settings]
+{
+  "terminal": {
+    "env": {
+      "AMP_FORCE_BEL": "1"
+    }
+  }
+}
+```
+
+Restart Amp after adding the environment variable.
+
+### OpenCode Notifications {#opencode-notifications}
+
+OpenCode can update terminal titles automatically. For Zed notifications, add an OpenCode plugin that emits a terminal bell when OpenCode needs your attention.
+
+Create `.opencode/plugins/zed-bell.js` in your project, or `~/.config/opencode/plugins/zed-bell.js` to use it globally:
+
+```js
+export const ZedBell = async () => {
+  return {
+    event: async ({ event }) => {
+      if (event.type === "session.idle" || event.type === "permission.asked") {
+        process.stdout.write("\x07");
+      }
+    },
+  };
+};
+```
+
+Restart OpenCode after adding the plugin.
+
+### Pi Notifications {#pi-notifications}
+
+Pi can use an extension to emit a notification when it finishes a turn. Create `.pi/extensions/zed-bell.ts` in your project, or `~/.pi/agent/extensions/zed-bell.ts` to use it globally:
+
+```ts
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export default function (pi: ExtensionAPI) {
+  pi.on("agent_end", async () => {
+    process.stdout.write("\x07");
+  });
+}
+```
+
+Restart Pi after adding the extension, or run `/reload` if the extension is in one of Pi's auto-discovered extension locations.
+
 ### Codex Terminal Titles {#codex-terminal-titles}
 
 Codex can update the terminal title as it works, which Zed uses to show useful context for Codex terminal threads in the sidebar — such as the project, current status, branch, model, or task progress.

From 0535f472918935181dc7551a90304553c9347315 Mon Sep 17 00:00:00 2001
From: Ben Brandt <benjamin.j.brandt@gmail.com>
Date: Tue, 19 May 2026 23:08:39 +0200
Subject: [PATCH 041/105] sidebar: Don't block worktree archival on empty
 drafts (#57145)

If we have empty drafts, they don't show up in the UI, so you can't get
rid of them. But they currently blocked worktree archival. Which is
particularly troublesome with terminal agents in a few cases.

This should hopefully solve the issue for terminals, but I think I need
to do a follow-up to investigate what happens when the last draft is
closed.

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Release Notes:

- N/A
---
 crates/agent_ui/src/agent_panel.rs            |  235 ++-
 crates/agent_ui/src/draft_prompt_store.rs     |   41 +-
 crates/agent_ui/src/thread_metadata_store.rs  |   69 +-
 .../agent_ui/src/thread_worktree_archive.rs   |   21 +
 crates/sidebar/src/sidebar.rs                 |  794 ++++++++---
 crates/sidebar/src/sidebar_tests.rs           | 1259 ++++++++++++++++-
 6 files changed, 2195 insertions(+), 224 deletions(-)

diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs
index 151a04d8bf3..862b007f52c 100644
--- a/crates/agent_ui/src/agent_panel.rs
+++ b/crates/agent_ui/src/agent_panel.rs
@@ -2758,6 +2758,25 @@ impl AgentPanel {
     /// the panel and deletes its metadata row. Used by the sidebar when
     /// the user dismisses a parked draft.
     pub fn remove_thread(&mut self, id: ThreadId, window: &mut Window, cx: &mut Context<Self>) {
+        self.remove_thread_internal(id, true, window, cx);
+    }
+
+    pub fn remove_thread_without_activating_draft(
+        &mut self,
+        id: ThreadId,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.remove_thread_internal(id, false, window, cx);
+    }
+
+    fn remove_thread_internal(
+        &mut self,
+        id: ThreadId,
+        activate_draft_after_remove: bool,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
         self.retained_threads.remove(&id);
         ThreadMetadataStore::global(cx).update(cx, |store, cx| {
             store.delete(id, cx);
@@ -2774,7 +2793,12 @@ impl AgentPanel {
 
         if self.active_thread_id(cx) == Some(id) {
             self.clear_overlay_state();
-            self.activate_draft(false, AgentThreadSource::AgentPanel, window, cx);
+            if activate_draft_after_remove {
+                self.activate_draft(false, AgentThreadSource::AgentPanel, window, cx);
+            } else {
+                self.base_view = BaseView::Uninitialized;
+                self.refresh_base_view_subscriptions(window, cx);
+            }
             self.serialize(cx);
             cx.emit(AgentPanelEvent::ActiveViewChanged);
             cx.notify();
@@ -2845,6 +2869,37 @@ impl AgentPanel {
         }
     }
 
+    pub fn draft_prompt_blocks_if_in_memory(
+        &self,
+        id: ThreadId,
+        cx: &App,
+    ) -> Option<Vec<acp::ContentBlock>> {
+        let cv = self
+            .retained_threads
+            .get(&id)
+            .or_else(|| {
+                self.draft_thread
+                    .as_ref()
+                    .filter(|draft| draft.read(cx).thread_id == id)
+            })
+            .or_else(|| match &self.base_view {
+                BaseView::AgentThread { conversation_view }
+                    if conversation_view.read(cx).thread_id == id =>
+                {
+                    Some(conversation_view)
+                }
+                _ => None,
+            })?;
+        let thread_view = cv.read(cx).root_thread_view()?;
+        let thread_view = thread_view.read(cx);
+        Some(
+            thread_view
+                .message_editor
+                .read(cx)
+                .draft_content_blocks_snapshot(cx),
+        )
+    }
+
     fn new_native_agent_thread_from_summary(
         &mut self,
         action: &NewNativeAgentThreadFromSummary,
@@ -6681,6 +6736,184 @@ mod tests {
         }
     }
 
+    #[gpui::test]
+    async fn test_draft_prompt_blocks_use_current_editor_snapshot(cx: &mut TestAppContext) {
+        init_test(cx);
+        cx.update(|cx| {
+            agent::ThreadStore::init_global(cx);
+            language_model::LanguageModelRegistry::test(cx);
+        });
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree("/project", json!({ "file.txt": "" })).await;
+        let project = Project::test(fs.clone(), [Path::new("/project")], cx).await;
+
+        let multi_workspace =
+            cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
+        let workspace = multi_workspace
+            .read_with(cx, |multi_workspace, _cx| {
+                multi_workspace.workspace().clone()
+            })
+            .unwrap();
+        let cx = &mut VisualTestContext::from_window(multi_workspace.into(), cx);
+        let panel = workspace.update_in(cx, |workspace, window, cx| {
+            let panel = cx.new(|cx| AgentPanel::new(workspace, None, window, cx));
+            workspace.add_panel(panel.clone(), window, cx);
+            panel
+        });
+
+        let _stub_connection =
+            crate::test_support::set_stub_agent_connection(StubAgentConnection::new());
+        panel.update_in(cx, |panel, window, cx| {
+            panel.selected_agent = Agent::Stub;
+            panel.activate_draft(true, AgentThreadSource::AgentPanel, window, cx);
+        });
+        cx.run_until_parked();
+
+        let thread_id = active_thread_id(&panel, cx);
+        let thread = panel.read_with(cx, |panel, cx| {
+            panel
+                .active_agent_thread(cx)
+                .expect("draft thread should be active")
+        });
+        let message_editor = panel.read_with(cx, |panel, cx| {
+            panel
+                .active_thread_view(cx)
+                .expect("draft thread view should be active")
+                .read(cx)
+                .message_editor
+                .clone()
+        });
+
+        thread.update(cx, |thread, cx| {
+            thread.set_draft_prompt(
+                Some(vec![acp::ContentBlock::Text(acp::TextContent::new(
+                    "stale prompt",
+                ))]),
+                cx,
+            );
+        });
+        message_editor.update_in(cx, |editor, window, cx| {
+            editor.set_text("fresh prompt", window, cx);
+        });
+        let blocks = panel.read_with(cx, |panel, cx| {
+            panel
+                .draft_prompt_blocks_if_in_memory(thread_id, cx)
+                .expect("draft should be in memory")
+        });
+        assert_eq!(blocks.len(), 1);
+        assert_eq!(expect_text_block(&blocks[0]), "fresh prompt");
+
+        thread.update(cx, |thread, cx| {
+            thread.set_draft_prompt(
+                Some(vec![acp::ContentBlock::Text(acp::TextContent::new(
+                    "stale prompt after clear",
+                ))]),
+                cx,
+            );
+        });
+        message_editor.update_in(cx, |editor, window, cx| {
+            editor.set_text("", window, cx);
+        });
+        let blocks = panel.read_with(cx, |panel, cx| {
+            panel
+                .draft_prompt_blocks_if_in_memory(thread_id, cx)
+                .expect("draft should be in memory")
+        });
+        assert!(
+            blocks.is_empty(),
+            "cleared editor snapshot should override stale saved draft prompt"
+        );
+    }
+
+    #[gpui::test]
+    async fn test_draft_has_user_content_checks_all_live_copies(cx: &mut TestAppContext) {
+        init_test(cx);
+        cx.update(|cx| {
+            agent::ThreadStore::init_global(cx);
+            language_model::LanguageModelRegistry::test(cx);
+        });
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree("/project_a", json!({ "file.txt": "" }))
+            .await;
+        fs.insert_tree("/project_b", json!({ "file.txt": "" }))
+            .await;
+        let project_a = Project::test(fs.clone(), [Path::new("/project_a")], cx).await;
+        let project_b = Project::test(fs.clone(), [Path::new("/project_b")], cx).await;
+
+        let multi_workspace =
+            cx.add_window(|window, cx| MultiWorkspace::test_new(project_a.clone(), window, cx));
+        let workspace_a = multi_workspace
+            .read_with(cx, |multi_workspace, _cx| {
+                multi_workspace.workspace().clone()
+            })
+            .unwrap();
+        let workspace_b = multi_workspace
+            .update(cx, |multi_workspace, window, cx| {
+                multi_workspace.test_add_workspace(project_b.clone(), window, cx)
+            })
+            .unwrap();
+
+        let cx = &mut VisualTestContext::from_window(multi_workspace.into(), cx);
+        let panel_a = workspace_a.update_in(cx, |workspace, window, cx| {
+            let panel = cx.new(|cx| AgentPanel::new(workspace, None, window, cx));
+            workspace.add_panel(panel.clone(), window, cx);
+            panel
+        });
+        let panel_b = workspace_b.update_in(cx, |workspace, window, cx| {
+            let panel = cx.new(|cx| AgentPanel::new(workspace, None, window, cx));
+            workspace.add_panel(panel.clone(), window, cx);
+            panel
+        });
+
+        let _stub_connection =
+            crate::test_support::set_stub_agent_connection(StubAgentConnection::new());
+        panel_a.update_in(cx, |panel, window, cx| {
+            panel.selected_agent = Agent::Stub;
+            panel.activate_draft(true, AgentThreadSource::AgentPanel, window, cx);
+        });
+        cx.run_until_parked();
+        let thread_id = active_thread_id(&panel_a, cx);
+
+        panel_b.update_in(cx, |panel, window, cx| {
+            panel.load_agent_thread(
+                Agent::Stub,
+                thread_id,
+                Some(PathList::new(&[PathBuf::from("/project_b")])),
+                None,
+                false,
+                AgentThreadSource::AgentPanel,
+                window,
+                cx,
+            );
+        });
+        cx.run_until_parked();
+
+        crate::test_support::type_draft_prompt(&panel_b, "content in second panel", cx);
+        let panel_a_blocks = panel_a.read_with(cx, |panel, cx| {
+            panel
+                .draft_prompt_blocks_if_in_memory(thread_id, cx)
+                .expect("draft should be live in first panel")
+        });
+        assert!(
+            panel_a_blocks.is_empty(),
+            "first live draft copy should be empty"
+        );
+
+        let has_user_content = cx.update(|_, cx| {
+            crate::draft_prompt_store::draft_has_user_content(
+                thread_id,
+                [&workspace_a, &workspace_b],
+                cx,
+            )
+        });
+        assert!(
+            has_user_content,
+            "a later live draft copy with content should keep the draft"
+        );
+    }
+
     #[test]
     fn test_build_conflict_resolution_prompt_single_conflict() {
         let conflicts = vec![ConflictContent {
diff --git a/crates/agent_ui/src/draft_prompt_store.rs b/crates/agent_ui/src/draft_prompt_store.rs
index 34d17d49994..c0b45ed7589 100644
--- a/crates/agent_ui/src/draft_prompt_store.rs
+++ b/crates/agent_ui/src/draft_prompt_store.rs
@@ -29,7 +29,7 @@ pub fn read(thread_id: ThreadId, cx: &App) -> Option<Vec<acp::ContentBlock>> {
     let kvp = KeyValueStore::global(cx);
     let raw = kvp
         .scoped(NAMESPACE)
-        .read(&thread_id_key(thread_id))
+        .read(&thread_id.to_key_string())
         .log_err()
         .flatten()?;
     serde_json::from_str(&raw).log_err()
@@ -41,7 +41,7 @@ pub fn write(
     cx: &App,
 ) -> Task<anyhow::Result<()>> {
     let kvp = KeyValueStore::global(cx);
-    let key = thread_id_key(thread_id);
+    let key = thread_id.to_key_string();
     let payload = match serde_json::to_string(prompt).context("serializing draft prompt") {
         Ok(payload) => payload,
         Err(err) => return Task::ready(Err(err)),
@@ -51,12 +51,43 @@ pub fn write(
 
 pub fn delete(thread_id: ThreadId, cx: &App) -> Task<anyhow::Result<()>> {
     let kvp = KeyValueStore::global(cx);
-    let key = thread_id_key(thread_id);
+    let key = thread_id.to_key_string();
     cx.background_spawn(async move { kvp.scoped(NAMESPACE).delete(key).await })
 }
 
-fn thread_id_key(thread_id: ThreadId) -> String {
-    thread_id.to_key_string()
+pub fn draft_has_user_content<'a>(
+    thread_id: ThreadId,
+    workspaces: impl IntoIterator<Item = &'a Entity<Workspace>>,
+    cx: &App,
+) -> bool {
+    let mut found_live_copy = false;
+    for blocks in workspaces
+        .into_iter()
+        .filter_map(|workspace| workspace.read(cx).panel::<AgentPanel>(cx))
+        .filter_map(|panel| {
+            panel
+                .read(cx)
+                .draft_prompt_blocks_if_in_memory(thread_id, cx)
+        })
+    {
+        found_live_copy = true;
+        if blocks_have_user_content(&blocks) {
+            return true;
+        }
+    }
+
+    if found_live_copy {
+        false
+    } else {
+        read(thread_id, cx).is_some_and(|blocks| blocks_have_user_content(&blocks))
+    }
+}
+
+fn blocks_have_user_content(blocks: &[acp::ContentBlock]) -> bool {
+    blocks.iter().any(|block| match block {
+        acp::ContentBlock::Text(text) => !text.text.trim().is_empty(),
+        _ => true,
+    })
 }
 
 /// Rewrites `[@Something](scheme://...)` mention links as `@Something` so the
diff --git a/crates/agent_ui/src/thread_metadata_store.rs b/crates/agent_ui/src/thread_metadata_store.rs
index 594b0d00b83..f3bbdaa0c9e 100644
--- a/crates/agent_ui/src/thread_metadata_store.rs
+++ b/crates/agent_ui/src/thread_metadata_store.rs
@@ -347,6 +347,20 @@ impl ThreadMetadata {
     pub fn main_worktree_paths(&self) -> &PathList {
         self.worktree_paths.main_worktree_path_list()
     }
+
+    pub fn references_folder_path(&self, path: &Path) -> bool {
+        self.folder_paths()
+            .paths()
+            .iter()
+            .any(|folder_path| folder_path.as_path() == path)
+    }
+
+    pub fn matches_remote_connection(
+        &self,
+        remote_connection: Option<&RemoteConnectionOptions>,
+    ) -> bool {
+        same_remote_connection_identity(self.remote_connection.as_ref(), remote_connection)
+    }
 }
 
 /// Derives worktree display info from a thread's stored path list.
@@ -615,9 +629,7 @@ impl ThreadMetadataStore {
             .flatten()
             .filter_map(|s| self.threads.get(s))
             .filter(|s| !s.archived)
-            .filter(move |s| {
-                same_remote_connection_identity(s.remote_connection.as_ref(), remote_connection)
-            })
+            .filter(move |s| s.matches_remote_connection(remote_connection))
     }
 
     /// Returns threads whose `main_worktree_paths` matches the given path list
@@ -639,9 +651,7 @@ impl ThreadMetadataStore {
             .flatten()
             .filter_map(|s| self.threads.get(s))
             .filter(|s| !s.archived)
-            .filter(move |s| {
-                same_remote_connection_identity(s.remote_connection.as_ref(), remote_connection)
-            })
+            .filter(move |s| s.matches_remote_connection(remote_connection))
     }
 
     fn reload(&mut self, cx: &mut Context<Self>) -> Shared<Task<()>> {
@@ -858,19 +868,28 @@ impl ThreadMetadataStore {
         thread_id: Option<ThreadId>,
         path: &Path,
         remote_connection: Option<&RemoteConnectionOptions>,
+    ) -> bool {
+        self.path_is_referenced_by_unarchived_threads_matching(
+            thread_id,
+            path,
+            remote_connection,
+            |_| true,
+        )
+    }
+
+    pub fn path_is_referenced_by_unarchived_threads_matching(
+        &self,
+        thread_id: Option<ThreadId>,
+        path: &Path,
+        remote_connection: Option<&RemoteConnectionOptions>,
+        matches: impl Fn(&ThreadMetadata) -> bool,
     ) -> bool {
         self.entries().any(|thread| {
             Some(thread.thread_id) != thread_id
                 && !thread.archived
-                && same_remote_connection_identity(
-                    thread.remote_connection.as_ref(),
-                    remote_connection,
-                )
-                && thread
-                    .folder_paths()
-                    .paths()
-                    .iter()
-                    .any(|other_path| other_path.as_path() == path)
+                && thread.matches_remote_connection(remote_connection)
+                && thread.references_folder_path(path)
+                && matches(thread)
         })
     }
 
@@ -1123,6 +1142,26 @@ impl ThreadMetadataStore {
         cx.notify();
     }
 
+    pub fn unarchived_draft_ids_matching(
+        &self,
+        matches: impl Fn(&ThreadMetadata) -> bool,
+    ) -> Vec<ThreadId> {
+        self.entries()
+            .filter(|thread| thread.is_draft() && !thread.archived && matches(thread))
+            .map(|thread| thread.thread_id)
+            .collect()
+    }
+
+    pub fn delete_all(
+        &mut self,
+        thread_ids: impl IntoIterator<Item = ThreadId>,
+        cx: &mut Context<Self>,
+    ) {
+        for thread_id in thread_ids {
+            self.delete(thread_id, cx);
+        }
+    }
+
     fn new(db: ThreadMetadataDb, cx: &mut Context<Self>) -> Self {
         let weak_store = cx.weak_entity();
 
diff --git a/crates/agent_ui/src/thread_worktree_archive.rs b/crates/agent_ui/src/thread_worktree_archive.rs
index b510da96b4e..f3d54657d49 100644
--- a/crates/agent_ui/src/thread_worktree_archive.rs
+++ b/crates/agent_ui/src/thread_worktree_archive.rs
@@ -831,6 +831,27 @@ pub fn all_open_workspaces(cx: &App) -> Vec<Entity<Workspace>> {
         .collect()
 }
 
+pub fn workspaces_for_archive(
+    multi_workspace: Option<&Entity<MultiWorkspace>>,
+    cx: &App,
+) -> Vec<Entity<Workspace>> {
+    let mut workspaces = multi_workspace
+        .map(|multi_workspace| {
+            multi_workspace
+                .read(cx)
+                .workspaces()
+                .cloned()
+                .collect::<Vec<_>>()
+        })
+        .unwrap_or_default();
+    for workspace in all_open_workspaces(cx) {
+        if !workspaces.contains(&workspace) {
+            workspaces.push(workspace);
+        }
+    }
+    workspaces
+}
+
 fn current_app_state(cx: &mut AsyncApp) -> Option<Arc<AppState>> {
     cx.update(|cx| {
         all_open_workspaces(cx)
diff --git a/crates/sidebar/src/sidebar.rs b/crates/sidebar/src/sidebar.rs
index 7fcaf38a3f5..1dfec54ebaa 100644
--- a/crates/sidebar/src/sidebar.rs
+++ b/crates/sidebar/src/sidebar.rs
@@ -475,10 +475,6 @@ fn linked_worktree_path_lists_for_workspaces(
         .collect()
 }
 
-fn workspace_has_terminal_metadata(workspace: &Entity<Workspace>, cx: &App) -> bool {
-    workspace_has_terminal_metadata_except(workspace, None, cx)
-}
-
 fn workspace_has_terminal_metadata_except(
     workspace: &Entity<Workspace>,
     except_terminal_id: Option<TerminalId>,
@@ -3657,6 +3653,7 @@ impl Sidebar {
     }
 
     fn should_load_closed_workspace_for_archive(
+        &self,
         folder_paths: &PathList,
         project_group_key: &ProjectGroupKey,
         remote_connection: Option<&RemoteConnectionOptions>,
@@ -3668,13 +3665,17 @@ impl Sidebar {
             return false;
         }
 
+        let archive_workspaces = self.archive_workspaces(cx);
         let thread_store = ThreadMetadataStore::global(cx);
         let thread_store = thread_store.read(cx);
         if folder_paths.ordered_paths().any(|path| {
-            thread_store.path_is_referenced_by_unarchived_threads(
+            Self::path_is_referenced_by_unarchived_threads_for_archive(
+                &thread_store,
                 except_thread_id,
                 path,
                 remote_connection,
+                &archive_workspaces,
+                cx,
             )
         }) {
             return false;
@@ -3692,6 +3693,208 @@ impl Sidebar {
         })
     }
 
+    fn path_is_referenced_by_unarchived_threads_for_archive(
+        thread_store: &ThreadMetadataStore,
+        except_thread_id: Option<ThreadId>,
+        path: &Path,
+        remote_connection: Option<&RemoteConnectionOptions>,
+        archive_workspaces: &[Entity<Workspace>],
+        cx: &App,
+    ) -> bool {
+        thread_store.path_is_referenced_by_unarchived_threads_matching(
+            except_thread_id,
+            path,
+            remote_connection,
+            |thread| Self::thread_blocks_worktree_archive(thread, archive_workspaces, cx),
+        )
+    }
+
+    fn archive_workspaces(&self, cx: &App) -> Vec<Entity<Workspace>> {
+        let multi_workspace = self.multi_workspace.upgrade();
+        thread_worktree_archive::workspaces_for_archive(multi_workspace.as_ref(), cx)
+    }
+
+    fn count_threads_blocking_worktree_archive(
+        &self,
+        path_list: &PathList,
+        remote_connection: Option<&RemoteConnectionOptions>,
+        except_thread_id: Option<ThreadId>,
+        cx: &App,
+    ) -> usize {
+        let archive_workspaces = self.archive_workspaces(cx);
+        ThreadMetadataStore::global(cx)
+            .read(cx)
+            .entries_for_path(path_list, remote_connection)
+            .filter(|thread| Some(thread.thread_id) != except_thread_id)
+            .filter(|thread| Self::thread_blocks_worktree_archive(thread, &archive_workspaces, cx))
+            .count()
+    }
+
+    fn roots_to_archive_for_paths(
+        &self,
+        folder_paths: &PathList,
+        remote_connection: Option<&RemoteConnectionOptions>,
+        except_thread_id: Option<ThreadId>,
+        except_terminal_id: Option<TerminalId>,
+        cx: &App,
+    ) -> Vec<thread_worktree_archive::RootPlan> {
+        let workspaces = self.archive_workspaces(cx);
+        folder_paths
+            .ordered_paths()
+            .filter_map(|path| {
+                thread_worktree_archive::build_root_plan(path, remote_connection, &workspaces, cx)
+            })
+            .filter(|plan| {
+                let store = ThreadMetadataStore::global(cx);
+                let store = store.read(cx);
+                !Self::path_is_referenced_by_unarchived_threads_for_archive(
+                    &store,
+                    except_thread_id,
+                    plan.root_path.as_path(),
+                    remote_connection,
+                    &workspaces,
+                    cx,
+                )
+            })
+            .filter(|root| {
+                TerminalThreadMetadataStore::try_global(cx).is_none_or(|terminal_store| {
+                    !terminal_store.read(cx).path_is_referenced_by_terminal(
+                        except_terminal_id,
+                        root.root_path.as_path(),
+                        remote_connection,
+                    )
+                })
+            })
+            .collect()
+    }
+
+    fn linked_worktree_workspace_to_remove(
+        &self,
+        folder_paths: &PathList,
+        remote_connection: Option<&RemoteConnectionOptions>,
+        except_thread_id: Option<ThreadId>,
+        except_terminal_id: Option<TerminalId>,
+        roots_to_archive: &[thread_worktree_archive::RootPlan],
+        cx: &App,
+    ) -> Option<Entity<Workspace>> {
+        if folder_paths.is_empty() {
+            return None;
+        }
+
+        let remaining = self.count_threads_blocking_worktree_archive(
+            folder_paths,
+            remote_connection,
+            except_thread_id,
+            cx,
+        );
+
+        if remaining > 0 {
+            return None;
+        }
+
+        let multi_workspace = self.multi_workspace.upgrade()?;
+        let workspace =
+            multi_workspace
+                .read(cx)
+                .workspace_for_paths(folder_paths, remote_connection, cx)?;
+
+        if workspace_has_terminal_metadata_except(&workspace, except_terminal_id, cx) {
+            return None;
+        }
+
+        if !roots_to_archive.is_empty() {
+            let archive_paths: HashSet<&Path> = roots_to_archive
+                .iter()
+                .map(|root| root.root_path.as_path())
+                .collect();
+            let project = workspace.read(cx).project().clone();
+            let visible_worktree_paths = project
+                .read(cx)
+                .visible_worktrees(cx)
+                .map(|worktree| worktree.read(cx).abs_path())
+                .collect::<Vec<_>>();
+            return (!visible_worktree_paths.is_empty()
+                && visible_worktree_paths
+                    .iter()
+                    .all(|path| archive_paths.contains(path.as_ref())))
+            .then_some(workspace);
+        }
+
+        let group_key = workspace.read(cx).project_group_key(cx);
+        (group_key.path_list() != folder_paths).then_some(workspace)
+    }
+
+    fn delete_empty_drafts_for_archive_roots(
+        &self,
+        roots: &[thread_worktree_archive::RootPlan],
+        cx: &mut Context<Self>,
+    ) {
+        self.delete_empty_drafts_for_archive_targets(
+            roots
+                .iter()
+                .map(|root| (root.root_path.as_path(), root.remote_connection.as_ref())),
+            cx,
+        );
+    }
+
+    fn delete_empty_drafts_for_archive_paths(
+        &self,
+        paths: &PathList,
+        remote_connection: Option<&RemoteConnectionOptions>,
+        cx: &mut Context<Self>,
+    ) {
+        self.delete_empty_drafts_for_archive_targets(
+            paths
+                .ordered_paths()
+                .map(|path| (path.as_path(), remote_connection)),
+            cx,
+        );
+    }
+
+    fn delete_empty_drafts_for_archive_targets<'a>(
+        &self,
+        targets: impl IntoIterator<Item = (&'a Path, Option<&'a RemoteConnectionOptions>)>,
+        cx: &mut Context<Self>,
+    ) {
+        let targets = targets.into_iter().collect::<Vec<_>>();
+        if targets.is_empty() {
+            return;
+        }
+
+        let archive_workspaces = self.archive_workspaces(cx);
+        let draft_thread_ids = ThreadMetadataStore::global(cx)
+            .read(cx)
+            .unarchived_draft_ids_matching(|thread| {
+                targets.iter().any(|(path, remote_connection)| {
+                    thread.matches_remote_connection(*remote_connection)
+                        && thread.references_folder_path(path)
+                }) && !Self::thread_blocks_worktree_archive(thread, &archive_workspaces, cx)
+            });
+        if draft_thread_ids.is_empty() {
+            return;
+        }
+
+        ThreadMetadataStore::global(cx).update(cx, |store, cx| {
+            store.delete_all(draft_thread_ids, cx);
+        });
+    }
+
+    fn thread_blocks_worktree_archive(
+        thread: &ThreadMetadata,
+        archive_workspaces: &[Entity<Workspace>],
+        cx: &App,
+    ) -> bool {
+        if !thread.is_draft() {
+            return true;
+        }
+
+        agent_ui::draft_prompt_store::draft_has_user_content(
+            thread.thread_id,
+            archive_workspaces,
+            cx,
+        )
+    }
+
     async fn wait_for_archive_workspace_metadata(
         workspace: &Entity<Workspace>,
         cx: &mut gpui::AsyncApp,
@@ -3821,7 +4024,7 @@ impl Sidebar {
             folder_paths,
             project_group_key,
         } = workspace
-            && Self::should_load_closed_workspace_for_archive(
+            && self.should_load_closed_workspace_for_archive(
                 folder_paths,
                 project_group_key,
                 metadata.remote_connection.as_ref(),
@@ -3859,83 +4062,22 @@ impl Sidebar {
             .and_then(|position| self.neighboring_activatable_entry(position));
 
         let terminal_folder_paths = metadata.folder_paths().clone();
-        let roots_to_archive = {
-            let mut workspaces = self
-                .multi_workspace
-                .upgrade()
-                .map(|multi_workspace| {
-                    multi_workspace
-                        .read(cx)
-                        .workspaces()
-                        .cloned()
-                        .collect::<Vec<_>>()
-                })
-                .unwrap_or_default();
-            for workspace in thread_worktree_archive::all_open_workspaces(cx) {
-                if !workspaces.contains(&workspace) {
-                    workspaces.push(workspace);
-                }
-            }
+        let roots_to_archive = self.roots_to_archive_for_paths(
+            metadata.folder_paths(),
+            metadata.remote_connection.as_ref(),
+            None,
+            Some(terminal_id),
+            cx,
+        );
 
-            metadata
-                .folder_paths()
-                .ordered_paths()
-                .filter_map(|path| {
-                    thread_worktree_archive::build_root_plan(
-                        path,
-                        metadata.remote_connection.as_ref(),
-                        &workspaces,
-                        cx,
-                    )
-                })
-                .filter(|plan| {
-                    let store = ThreadMetadataStore::global(cx);
-                    let store = store.read(cx);
-                    !store.path_is_referenced_by_unarchived_threads(
-                        None,
-                        &plan.root_path,
-                        metadata.remote_connection.as_ref(),
-                    )
-                })
-                .filter(|root| {
-                    TerminalThreadMetadataStore::try_global(cx).is_none_or(|terminal_store| {
-                        !terminal_store.read(cx).path_is_referenced_by_terminal(
-                            Some(terminal_id),
-                            root.root_path.as_path(),
-                            metadata.remote_connection.as_ref(),
-                        )
-                    })
-                })
-                .collect::<Vec<_>>()
-        };
-
-        let workspace_to_remove = if terminal_folder_paths.is_empty() {
-            None
-        } else {
-            let remaining = ThreadMetadataStore::global(cx)
-                .read(cx)
-                .entries_for_path(&terminal_folder_paths, metadata.remote_connection.as_ref())
-                .count();
-
-            if remaining > 0 {
-                None
-            } else {
-                let workspace = self.multi_workspace.upgrade().and_then(|multi_workspace| {
-                    multi_workspace
-                        .read(cx)
-                        .workspace_for_paths(&terminal_folder_paths, None, cx)
-                });
-
-                workspace.and_then(|workspace| {
-                    if workspace_has_terminal_metadata_except(&workspace, Some(terminal_id), cx) {
-                        return None;
-                    }
-
-                    let group_key = workspace.read(cx).project_group_key(cx);
-                    (group_key.path_list() != &terminal_folder_paths).then_some(workspace)
-                })
-            }
-        };
+        let workspace_to_remove = self.linked_worktree_workspace_to_remove(
+            &terminal_folder_paths,
+            metadata.remote_connection.as_ref(),
+            None,
+            Some(terminal_id),
+            &roots_to_archive,
+            cx,
+        );
 
         let mut workspaces_to_remove: Vec<Entity<Workspace>> =
             workspace_to_remove.into_iter().collect();
@@ -4003,6 +4145,13 @@ impl Sidebar {
                 }
 
                 this.update_in(cx, |this, window, cx| {
+                    if terminal_workspace_removed {
+                        this.delete_empty_drafts_for_archive_paths(
+                            metadata.folder_paths(),
+                            metadata.remote_connection.as_ref(),
+                            cx,
+                        );
+                    }
                     // If the terminal's workspace has already been removed,
                     // don't synthesize a fallback draft in the detached
                     // AgentPanel.
@@ -4193,33 +4342,44 @@ impl Sidebar {
     ) {
         let store = ThreadMetadataStore::global(cx);
         let metadata = store.read(cx).entry_by_session(session_id).cloned();
-        let active_workspace = metadata.as_ref().and_then(|metadata| {
+        let metadata_thread_id = metadata.as_ref().map(|metadata| metadata.thread_id);
+        let thread_entry = self.contents.entries.iter().find_map(|entry| match entry {
+            ListEntry::Thread(thread) => metadata_thread_id
+                .map_or_else(
+                    || thread.metadata.session_id.as_ref() == Some(session_id),
+                    |thread_id| thread.metadata.thread_id == thread_id,
+                )
+                .then(|| thread.clone()),
+            _ => None,
+        });
+        let thread_id = metadata_thread_id.or_else(|| {
+            thread_entry
+                .as_ref()
+                .map(|thread| thread.metadata.thread_id)
+        });
+        let active_workspace = thread_id.and_then(|thread_id| {
             self.active_entry.as_ref().and_then(|entry| {
-                if entry.is_active_thread(&metadata.thread_id) {
+                if entry.is_active_thread(&thread_id) {
                     Some(entry.workspace().clone())
                 } else {
                     None
                 }
             })
         });
-        let thread_id = metadata.as_ref().map(|metadata| metadata.thread_id);
         let thread_folder_paths = metadata
             .as_ref()
             .map(|metadata| metadata.folder_paths().clone())
+            .or_else(|| {
+                thread_entry
+                    .as_ref()
+                    .map(|thread| thread.metadata.folder_paths().clone())
+            })
             .or_else(|| {
                 active_workspace
                     .as_ref()
                     .map(|workspace| PathList::new(&workspace.read(cx).root_paths(cx)))
             });
-        let thread_entry_workspace = self.contents.entries.iter().find_map(|entry| match entry {
-            ListEntry::Thread(thread) => thread_id
-                .map_or_else(
-                    || thread.metadata.session_id.as_ref() == Some(session_id),
-                    |tid| thread.metadata.thread_id == tid,
-                )
-                .then(|| thread.workspace.clone()),
-            _ => None,
-        });
+        let thread_entry_workspace = thread_entry.map(|thread| thread.workspace);
 
         if let (
             Some(metadata),
@@ -4228,7 +4388,7 @@ impl Sidebar {
                 project_group_key,
             }),
         ) = (metadata.as_ref(), thread_entry_workspace)
-            && Self::should_load_closed_workspace_for_archive(
+            && self.should_load_closed_workspace_for_archive(
                 &folder_paths,
                 &project_group_key,
                 metadata.remote_connection.as_ref(),
@@ -4255,52 +4415,13 @@ impl Sidebar {
         let roots_to_archive = metadata
             .as_ref()
             .map(|metadata| {
-                let mut workspaces = self
-                    .multi_workspace
-                    .upgrade()
-                    .map(|multi_workspace| {
-                        multi_workspace
-                            .read(cx)
-                            .workspaces()
-                            .cloned()
-                            .collect::<Vec<_>>()
-                    })
-                    .unwrap_or_default();
-                for workspace in thread_worktree_archive::all_open_workspaces(cx) {
-                    if !workspaces.contains(&workspace) {
-                        workspaces.push(workspace);
-                    }
-                }
-                metadata
-                    .folder_paths()
-                    .ordered_paths()
-                    .filter_map(|path| {
-                        thread_worktree_archive::build_root_plan(
-                            path,
-                            metadata.remote_connection.as_ref(),
-                            &workspaces,
-                            cx,
-                        )
-                    })
-                    .filter(|plan| {
-                        thread_id.map_or(true, |tid| {
-                            !store.read(cx).path_is_referenced_by_unarchived_threads(
-                                Some(tid),
-                                &plan.root_path,
-                                metadata.remote_connection.as_ref(),
-                            )
-                        })
-                    })
-                    .filter(|root| {
-                        TerminalThreadMetadataStore::try_global(cx).is_none_or(|terminal_store| {
-                            !terminal_store.read(cx).path_is_referenced_by_terminal(
-                                None,
-                                root.root_path.as_path(),
-                                metadata.remote_connection.as_ref(),
-                            )
-                        })
-                    })
-                    .collect::<Vec<_>>()
+                self.roots_to_archive_for_paths(
+                    metadata.folder_paths(),
+                    metadata.remote_connection.as_ref(),
+                    thread_id,
+                    None,
+                    cx,
+                )
             })
             .unwrap_or_default();
 
@@ -4317,35 +4438,16 @@ impl Sidebar {
         // Check if archiving this thread would leave its worktree workspace
         // with no threads, requiring workspace removal.
         let workspace_to_remove = thread_folder_paths.as_ref().and_then(|folder_paths| {
-            if folder_paths.is_empty() {
-                return None;
-            }
-
             let thread_remote_connection =
                 metadata.as_ref().and_then(|m| m.remote_connection.as_ref());
-            let remaining = ThreadMetadataStore::global(cx)
-                .read(cx)
-                .entries_for_path(folder_paths, thread_remote_connection)
-                .filter(|t| t.session_id.as_ref() != Some(session_id))
-                .count();
-
-            if remaining > 0 {
-                return None;
-            }
-
-            let multi_workspace = self.multi_workspace.upgrade()?;
-            let workspace = multi_workspace
-                .read(cx)
-                .workspace_for_paths(folder_paths, None, cx)?;
-
-            if workspace_has_terminal_metadata(&workspace, cx) {
-                return None;
-            }
-
-            let group_key = workspace.read(cx).project_group_key(cx);
-            let is_linked_worktree = group_key.path_list() != folder_paths;
-
-            is_linked_worktree.then_some(workspace)
+            self.linked_worktree_workspace_to_remove(
+                folder_paths,
+                thread_remote_connection,
+                thread_id,
+                None,
+                &roots_to_archive,
+                cx,
+            )
         });
 
         // Also find workspaces for root plans that aren't covered by
@@ -4407,6 +4509,9 @@ impl Sidebar {
             });
 
             let thread_folder_paths = thread_folder_paths.clone();
+            let thread_remote_connection = metadata
+                .as_ref()
+                .and_then(|metadata| metadata.remote_connection.clone());
             cx.spawn_in(window, async move |this, cx| {
                 if !remove_task.await? {
                     return anyhow::Ok(());
@@ -4418,6 +4523,13 @@ impl Sidebar {
                 }
 
                 this.update_in(cx, |this, window, cx| {
+                    if let Some(thread_folder_paths) = thread_folder_paths.as_ref() {
+                        this.delete_empty_drafts_for_archive_paths(
+                            thread_folder_paths,
+                            thread_remote_connection.as_ref(),
+                            cx,
+                        );
+                    }
                     let in_flight = thread_id.and_then(|tid| {
                         this.start_archive_worktree_task(tid, roots_to_archive, cx)
                     });
@@ -4426,6 +4538,7 @@ impl Sidebar {
                         thread_id,
                         neighbor.as_ref(),
                         thread_folder_paths.as_ref(),
+                        thread_remote_connection.as_ref(),
                         in_flight,
                         window,
                         cx,
@@ -4437,6 +4550,9 @@ impl Sidebar {
         } else if !close_item_tasks.is_empty() {
             let session_id = session_id.clone();
             let thread_folder_paths = thread_folder_paths.clone();
+            let thread_remote_connection = metadata
+                .as_ref()
+                .and_then(|metadata| metadata.remote_connection.clone());
             cx.spawn_in(window, async move |this, cx| {
                 for task in close_item_tasks {
                     let result: anyhow::Result<()> = task.await;
@@ -4452,6 +4568,7 @@ impl Sidebar {
                         thread_id,
                         neighbor.as_ref(),
                         thread_folder_paths.as_ref(),
+                        thread_remote_connection.as_ref(),
                         in_flight,
                         window,
                         cx,
@@ -4468,6 +4585,9 @@ impl Sidebar {
                 thread_id,
                 neighbor.as_ref(),
                 thread_folder_paths.as_ref(),
+                metadata
+                    .as_ref()
+                    .and_then(|metadata| metadata.remote_connection.as_ref()),
                 in_flight,
                 window,
                 cx,
@@ -4497,6 +4617,7 @@ impl Sidebar {
         thread_id: Option<agent_ui::ThreadId>,
         neighbor: Option<&ActivatableEntry>,
         thread_folder_paths: Option<&PathList>,
+        thread_remote_connection: Option<&RemoteConnectionOptions>,
         in_flight_archive: Option<(Task<()>, async_channel::Sender<()>)>,
         window: &mut Window,
         cx: &mut Context<Self>,
@@ -4521,11 +4642,10 @@ impl Sidebar {
             // archived thread from its workspace's panel so that switching
             // to that workspace later doesn't show a stale thread.
             if let Some(folder_paths) = thread_folder_paths {
-                if let Some(workspace) = self
-                    .multi_workspace
-                    .upgrade()
-                    .and_then(|mw| mw.read(cx).workspace_for_paths(folder_paths, None, cx))
-                {
+                if let Some(workspace) = self.multi_workspace.upgrade().and_then(|mw| {
+                    mw.read(cx)
+                        .workspace_for_paths(folder_paths, thread_remote_connection, cx)
+                }) {
                     if let Some(panel) = workspace.read(cx).panel::<AgentPanel>(cx) {
                         let panel_shows_archived = panel
                             .read(cx)
@@ -4552,10 +4672,10 @@ impl Sidebar {
         // No neighbor or its workspace isn't open — just clear the
         // panel so the group is left empty.
         if let Some(folder_paths) = thread_folder_paths {
-            let workspace = self
-                .multi_workspace
-                .upgrade()
-                .and_then(|mw| mw.read(cx).workspace_for_paths(folder_paths, None, cx));
+            let workspace = self.multi_workspace.upgrade().and_then(|mw| {
+                mw.read(cx)
+                    .workspace_for_paths(folder_paths, thread_remote_connection, cx)
+            });
             if let Some(workspace) = workspace {
                 if let Some(panel) = workspace.read(cx).panel::<AgentPanel>(cx) {
                     panel.update(cx, |panel, cx| {
@@ -4576,6 +4696,8 @@ impl Sidebar {
             return None;
         }
 
+        self.delete_empty_drafts_for_archive_roots(&roots, cx);
+
         let (cancel_tx, cancel_rx) = async_channel::bounded::<()>(1);
         let task = cx.spawn(async move |_this, cx| {
             match Self::archive_worktree_roots(roots, cancel_rx, cx).await {
@@ -4610,6 +4732,8 @@ impl Sidebar {
             return;
         }
 
+        self.delete_empty_drafts_for_archive_roots(&roots, cx);
+
         let (cancel_tx, cancel_rx) = async_channel::bounded::<()>(1);
         cx.spawn(async move |_this, cx| {
             let outcome = Self::archive_worktree_roots(roots, cancel_rx, cx).await;
@@ -4617,7 +4741,7 @@ impl Sidebar {
             match outcome {
                 Ok(ArchiveWorktreeOutcome::Success | ArchiveWorktreeOutcome::Cancelled) => {}
                 Err(error) => {
-                    log::error!("Failed to archive worktree after closing terminal: {error:#}");
+                    log::error!("Failed to archive worktree after closing sidebar item: {error:#}");
                 }
             }
         })
@@ -4706,11 +4830,9 @@ impl Sidebar {
                     AgentThreadStatus::Completed | AgentThreadStatus::Error => {}
                 }
                 if thread.is_draft {
-                    if let ThreadEntryWorkspace::Open(workspace) = &thread.workspace {
-                        let workspace = workspace.clone();
-                        let draft_id = thread.metadata.thread_id;
-                        self.remove_draft(draft_id, &workspace, window, cx);
-                    }
+                    let workspace = thread.workspace.clone();
+                    let draft_id = thread.metadata.thread_id;
+                    self.remove_draft(draft_id, &workspace, window, cx);
                 } else if let Some(session_id) = thread.metadata.session_id.clone() {
                     self.archive_thread(&session_id, window, cx);
                 }
@@ -5263,9 +5385,12 @@ impl Sidebar {
                         .on_click({
                             let thread_workspace = thread_workspace.clone();
                             cx.listener(move |this, _, window, cx| {
-                                if let ThreadEntryWorkspace::Open(workspace) = &thread_workspace {
-                                    this.remove_draft(thread_id_for_actions, workspace, window, cx);
-                                }
+                                this.remove_draft(
+                                    thread_id_for_actions,
+                                    &thread_workspace,
+                                    window,
+                                    cx,
+                                );
                             })
                         }),
                 )
@@ -5460,30 +5585,301 @@ impl Sidebar {
         }
     }
 
-    /// Deletes a parked draft thread (its metadata row, any kvp-stored
-    /// draft prompt) and promotes a sibling in the same group, if any, to
-    /// the active entry.
-    fn remove_draft(
+    /// Closed linked-worktree drafts need an open workspace so archive root
+    /// planning can inspect repositories before deleting the worktree.
+    fn open_workspace_and_remove_draft(
         &mut self,
         draft_id: ThreadId,
-        workspace: &Entity<Workspace>,
+        folder_paths: PathList,
+        project_group_key: ProjectGroupKey,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        workspace.update(cx, |ws, cx| {
-            if let Some(panel) = ws.panel::<AgentPanel>(cx) {
-                panel.update(cx, |panel, cx| {
-                    panel.remove_thread(draft_id, window, cx);
-                });
-            }
-        });
+        let Some((open_task, modal_workspace)) =
+            self.open_workspace_for_archive(folder_paths, project_group_key, window, cx)
+        else {
+            return;
+        };
+
+        cx.spawn_in(window, async move |this, cx| {
+            let result = open_task.await;
+            remote_connection::dismiss_connection_modal(&modal_workspace, cx);
+            let workspace = result?;
+            Self::wait_for_archive_workspace_metadata(&workspace, cx).await;
+
+            this.update_in(cx, |this, window, cx| {
+                let workspace = ThreadEntryWorkspace::Open(workspace);
+                this.remove_draft(draft_id, &workspace, window, cx);
+            })?;
+            anyhow::Ok(())
+        })
+        .detach_and_log_err(cx);
+    }
+
+    fn remove_draft(
+        &mut self,
+        draft_id: ThreadId,
+        workspace: &ThreadEntryWorkspace,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let metadata = ThreadMetadataStore::global(cx)
+            .read(cx)
+            .entry(draft_id)
+            .cloned();
+
+        if let ThreadEntryWorkspace::Closed {
+            folder_paths,
+            project_group_key,
+        } = workspace
+            && self.should_load_closed_workspace_for_archive(
+                folder_paths,
+                project_group_key,
+                metadata
+                    .as_ref()
+                    .and_then(|metadata| metadata.remote_connection.as_ref()),
+                Some(draft_id),
+                None,
+                cx,
+            )
+        {
+            self.open_workspace_and_remove_draft(
+                draft_id,
+                folder_paths.clone(),
+                project_group_key.clone(),
+                window,
+                cx,
+            );
+            return;
+        }
+
+        let draft_folder_paths = metadata
+            .as_ref()
+            .map(|metadata| metadata.folder_paths().clone())
+            .or_else(|| match workspace {
+                ThreadEntryWorkspace::Open(workspace) => {
+                    Some(PathList::new(&workspace.read(cx).root_paths(cx)))
+                }
+                ThreadEntryWorkspace::Closed { folder_paths, .. } => Some(folder_paths.clone()),
+            });
+        let draft_remote_connection = metadata
+            .as_ref()
+            .and_then(|metadata| metadata.remote_connection.clone());
+        let roots_to_archive = metadata
+            .as_ref()
+            .map(|metadata| {
+                self.roots_to_archive_for_paths(
+                    metadata.folder_paths(),
+                    metadata.remote_connection.as_ref(),
+                    Some(draft_id),
+                    None,
+                    cx,
+                )
+            })
+            .unwrap_or_default();
 
         let was_active = self
             .active_entry
             .as_ref()
-            .is_some_and(|e| e.is_active_thread(&draft_id));
+            .is_some_and(|entry| entry.is_active_thread(&draft_id));
+        let neighbor = self
+            .contents
+            .entries
+            .iter()
+            .position(|entry| {
+                matches!(
+                    entry,
+                    ListEntry::Thread(thread) if thread.metadata.thread_id == draft_id
+                )
+            })
+            .and_then(|position| self.neighboring_activatable_entry(position));
+
+        let workspace_to_remove = draft_folder_paths.as_ref().and_then(|folder_paths| {
+            self.linked_worktree_workspace_to_remove(
+                folder_paths,
+                draft_remote_connection.as_ref(),
+                Some(draft_id),
+                None,
+                &roots_to_archive,
+                cx,
+            )
+        });
+        let mut workspaces_to_remove: Vec<Entity<Workspace>> =
+            workspace_to_remove.into_iter().collect();
+        let close_item_tasks = self.close_items_for_archived_worktrees(
+            &roots_to_archive,
+            &mut workspaces_to_remove,
+            window,
+            cx,
+        );
+
+        if !workspaces_to_remove.is_empty() {
+            let Some(multi_workspace) = self.multi_workspace.upgrade() else {
+                return;
+            };
+            let draft_workspace_removed = matches!(
+                workspace,
+                ThreadEntryWorkspace::Open(workspace) if workspaces_to_remove.contains(workspace)
+            );
+            let (fallback_paths, project_group_key) = neighbor
+                .as_ref()
+                .map(|neighbor| neighbor.project_location(cx))
+                .unwrap_or_else(|| {
+                    workspaces_to_remove
+                        .first()
+                        .map(|workspace| {
+                            let key = workspace.read(cx).project_group_key(cx);
+                            (key.path_list().clone(), key)
+                        })
+                        .unwrap_or_default()
+                });
+
+            let excluded = workspaces_to_remove.clone();
+            let remove_task = multi_workspace.update(cx, |multi_workspace, cx| {
+                multi_workspace.remove(
+                    workspaces_to_remove,
+                    move |this, window, cx| {
+                        let active_workspace = this.workspace().clone();
+                        this.find_or_create_workspace(
+                            fallback_paths,
+                            project_group_key.host(),
+                            Some(project_group_key),
+                            |options, window, cx| {
+                                connect_remote(active_workspace, options, window, cx)
+                            },
+                            &excluded,
+                            None,
+                            OpenMode::Activate,
+                            window,
+                            cx,
+                        )
+                    },
+                    window,
+                    cx,
+                )
+            });
+
+            let workspace = workspace.clone();
+            cx.spawn_in(window, async move |this, cx| {
+                if !remove_task.await? {
+                    return anyhow::Ok(());
+                }
+
+                for task in close_item_tasks {
+                    let result: anyhow::Result<()> = task.await;
+                    result.log_err();
+                }
+
+                this.update_in(cx, |this, window, cx| {
+                    if draft_workspace_removed {
+                        if let Some(draft_folder_paths) = draft_folder_paths.as_ref() {
+                            this.delete_empty_drafts_for_archive_paths(
+                                draft_folder_paths,
+                                draft_remote_connection.as_ref(),
+                                cx,
+                            );
+                        }
+                    }
+                    this.remove_draft_entry(
+                        draft_id,
+                        &workspace,
+                        was_active,
+                        neighbor.as_ref(),
+                        !draft_workspace_removed,
+                        roots_to_archive,
+                        window,
+                        cx,
+                    );
+                })?;
+                anyhow::Ok(())
+            })
+            .detach_and_log_err(cx);
+        } else if !close_item_tasks.is_empty() {
+            let workspace = workspace.clone();
+            cx.spawn_in(window, async move |this, cx| {
+                for task in close_item_tasks {
+                    let result: anyhow::Result<()> = task.await;
+                    result.log_err();
+                }
+
+                this.update_in(cx, |this, window, cx| {
+                    this.remove_draft_entry(
+                        draft_id,
+                        &workspace,
+                        was_active,
+                        neighbor.as_ref(),
+                        true,
+                        roots_to_archive,
+                        window,
+                        cx,
+                    );
+                })?;
+                anyhow::Ok(())
+            })
+            .detach_and_log_err(cx);
+        } else {
+            self.remove_draft_entry(
+                draft_id,
+                workspace,
+                was_active,
+                neighbor.as_ref(),
+                true,
+                roots_to_archive,
+                window,
+                cx,
+            );
+        }
+    }
+
+    fn remove_draft_entry(
+        &mut self,
+        draft_id: ThreadId,
+        workspace: &ThreadEntryWorkspace,
+        was_active: bool,
+        neighbor: Option<&ActivatableEntry>,
+        activate_panel_draft: bool,
+        roots_to_archive: Vec<thread_worktree_archive::RootPlan>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let removed_from_panel = if let ThreadEntryWorkspace::Open(workspace) = workspace {
+            workspace.update(cx, |workspace, cx| {
+                if let Some(panel) = workspace.panel::<AgentPanel>(cx) {
+                    panel.update(cx, |panel, cx| {
+                        if activate_panel_draft {
+                            panel.remove_thread(draft_id, window, cx);
+                        } else {
+                            panel.remove_thread_without_activating_draft(draft_id, window, cx);
+                        }
+                    });
+                    true
+                } else {
+                    false
+                }
+            })
+        } else {
+            false
+        };
+
+        if !removed_from_panel {
+            ThreadMetadataStore::global(cx).update(cx, |store, cx| {
+                store.delete(draft_id, cx);
+            });
+        }
+
+        self.start_detached_archive_worktree_task(roots_to_archive, cx);
+
         if was_active {
             self.active_entry = None;
+            if !activate_panel_draft {
+                if neighbor
+                    .as_ref()
+                    .is_some_and(|neighbor| self.activate_entry(neighbor, window, cx))
+                {
+                    return;
+                }
+                self.sync_active_entry_from_active_workspace(cx);
+            }
         }
 
         self.update_entries(cx);
diff --git a/crates/sidebar/src/sidebar_tests.rs b/crates/sidebar/src/sidebar_tests.rs
index 982f0c6cd24..c65eda086ab 100644
--- a/crates/sidebar/src/sidebar_tests.rs
+++ b/crates/sidebar/src/sidebar_tests.rs
@@ -454,6 +454,34 @@ fn save_thread_metadata_with_main_paths(
     cx.run_until_parked();
 }
 
+fn save_draft_metadata_with_main_paths(
+    title: Option<SharedString>,
+    folder_paths: PathList,
+    main_worktree_paths: PathList,
+    updated_at: DateTime<Utc>,
+    cx: &mut TestAppContext,
+) -> ThreadId {
+    let thread_id = ThreadId::new();
+    let metadata = ThreadMetadata {
+        thread_id,
+        session_id: None,
+        agent_id: agent::ZED_AGENT_ID.clone(),
+        title,
+        title_override: None,
+        updated_at,
+        created_at: None,
+        interacted_at: None,
+        worktree_paths: WorktreePaths::from_path_lists(main_worktree_paths, folder_paths).unwrap(),
+        archived: false,
+        remote_connection: None,
+    };
+    cx.update(|cx| {
+        ThreadMetadataStore::global(cx).update(cx, |store, cx| store.save(metadata, cx));
+    });
+    cx.run_until_parked();
+    thread_id
+}
+
 fn focus_sidebar(sidebar: &Entity<Sidebar>, cx: &mut gpui::VisualTestContext) {
     sidebar.update_in(cx, |_, window, cx| {
         cx.focus_self(window);
@@ -1884,6 +1912,8 @@ async fn test_terminal_close_event_on_archived_linked_worktree_removes_workspace
         multi_workspace.test_add_workspace(worktree_project.clone(), window, cx)
     });
     let worktree_panel = add_agent_panel(&worktree_workspace, cx);
+    let worktree_folder_paths =
+        PathList::new(&[PathBuf::from("/worktrees/project/feature-a/project")]);
 
     let archived_session_id = acp::SessionId::new(Arc::from("archived-wt-thread"));
     save_thread_metadata(
@@ -1916,6 +1946,19 @@ async fn test_terminal_close_event_on_archived_linked_worktree_removes_workspace
         &main_project,
         cx,
     );
+    let empty_draft_id = save_draft_metadata_with_main_paths(
+        None,
+        worktree_folder_paths.clone(),
+        PathList::new(&[PathBuf::from("/project")]),
+        chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 3, 0, 0, 0).unwrap(),
+        cx,
+    );
+    cx.update(|_, cx| {
+        assert!(
+            agent_ui::draft_prompt_store::read(empty_draft_id, cx).is_none(),
+            "empty draft should not have persisted prompt content"
+        );
+    });
 
     let terminal_id = worktree_panel
         .update_in(cx, |panel, window, cx| {
@@ -1956,12 +1999,20 @@ async fn test_terminal_close_event_on_archived_linked_worktree_removes_workspace
         terminal_metadata_deleted,
         "terminal metadata should be deleted after close"
     );
-    let unarchived_worktree_threads = cx.update(|_, cx| {
-        let worktree_path_list =
-            PathList::new(&[PathBuf::from("/worktrees/project/feature-a/project")]);
+    let empty_draft_metadata_deleted = cx.update(|_, cx| {
         ThreadMetadataStore::global(cx)
             .read(cx)
-            .entries_for_path(&worktree_path_list, None)
+            .entry(empty_draft_id)
+            .is_none()
+    });
+    assert!(
+        empty_draft_metadata_deleted,
+        "empty draft metadata should be deleted before archiving the linked worktree"
+    );
+    let unarchived_worktree_threads = cx.update(|_, cx| {
+        ThreadMetadataStore::global(cx)
+            .read(cx)
+            .entries_for_path(&worktree_folder_paths, None)
             .count()
     });
     assert_eq!(
@@ -1987,6 +2038,672 @@ async fn test_terminal_close_event_on_archived_linked_worktree_removes_workspace
     );
 }
 
+#[gpui::test]
+async fn test_terminal_close_event_deletes_empty_draft_when_linked_worktree_has_no_archive_root(
+    cx: &mut TestAppContext,
+) {
+    init_test(cx);
+
+    let fs = FakeFs::new(cx.executor());
+    fs.insert_tree(
+        "/project",
+        serde_json::json!({
+            ".git": {},
+            "src": {},
+        }),
+    )
+    .await;
+    fs.set_branch_name(Path::new("/project/.git"), Some("main"));
+    fs.insert_branches(Path::new("/project/.git"), &["main", "feature-a"]);
+    fs.add_linked_worktree_for_repo(
+        Path::new("/project/.git"),
+        false,
+        git::repository::Worktree {
+            path: PathBuf::from("/external-worktree"),
+            ref_name: Some("refs/heads/feature-a".into()),
+            sha: "aaa".into(),
+            is_main: false,
+            is_bare: false,
+        },
+    )
+    .await;
+    cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));
+
+    let main_project = project::Project::test(fs.clone(), ["/project".as_ref()], cx).await;
+    let worktree_project =
+        project::Project::test(fs.clone(), ["/external-worktree".as_ref()], cx).await;
+
+    main_project
+        .update(cx, |project, cx| project.git_scans_complete(cx))
+        .await;
+    worktree_project
+        .update(cx, |project, cx| project.git_scans_complete(cx))
+        .await;
+
+    let (multi_workspace, cx) =
+        cx.add_window_view(|window, cx| MultiWorkspace::test_new(main_project.clone(), window, cx));
+    let _sidebar = setup_sidebar(&multi_workspace, cx);
+    let worktree_workspace = multi_workspace.update_in(cx, |multi_workspace, window, cx| {
+        multi_workspace.test_add_workspace(worktree_project.clone(), window, cx)
+    });
+    let worktree_panel = add_agent_panel(&worktree_workspace, cx);
+
+    save_thread_metadata(
+        acp::SessionId::new(Arc::from("main-thread")),
+        Some("Main Thread".into()),
+        chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 2, 0, 0, 0).unwrap(),
+        None,
+        None,
+        &main_project,
+        cx,
+    );
+
+    let worktree_folder_paths = PathList::new(&[PathBuf::from("/external-worktree")]);
+    let empty_draft_id = save_draft_metadata_with_main_paths(
+        None,
+        worktree_folder_paths.clone(),
+        PathList::new(&[PathBuf::from("/project")]),
+        chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 3, 0, 0, 0).unwrap(),
+        cx,
+    );
+
+    let terminal_id = worktree_panel
+        .update_in(cx, |panel, window, cx| {
+            panel.insert_test_terminal("Dev Server", true, window, cx)
+        })
+        .expect("test terminal should be inserted");
+    cx.run_until_parked();
+
+    worktree_panel.update(cx, |panel, cx| {
+        panel.emit_test_terminal_close(terminal_id, cx);
+    });
+    for _ in 0..4 {
+        cx.run_until_parked();
+    }
+
+    let empty_draft_metadata_deleted = cx.update(|_, cx| {
+        ThreadMetadataStore::global(cx)
+            .read(cx)
+            .entry(empty_draft_id)
+            .is_none()
+    });
+    assert!(
+        empty_draft_metadata_deleted,
+        "empty draft metadata should be deleted when removing the linked worktree workspace"
+    );
+    assert!(
+        multi_workspace
+            .read_with(cx, |multi_workspace, cx| {
+                multi_workspace.workspace_for_paths(&worktree_folder_paths, None, cx)
+            })
+            .is_none(),
+        "linked worktree workspace should be removed after closing its last terminal"
+    );
+    assert!(
+        fs.is_dir(Path::new("/external-worktree")).await,
+        "external linked worktree directory should remain on disk when no archive root is produced"
+    );
+}
+
+#[gpui::test]
+async fn test_terminal_close_event_keeps_linked_worktree_workspace_with_live_editor_draft(
+    cx: &mut TestAppContext,
+) {
+    init_test(cx);
+
+    let fs = FakeFs::new(cx.executor());
+    fs.insert_tree(
+        "/project",
+        serde_json::json!({
+            ".git": {
+                "worktrees": {
+                    "feature-a": {
+                        "commondir": "../../",
+                        "HEAD": "ref: refs/heads/feature-a",
+                    },
+                },
+            },
+            "src": {},
+        }),
+    )
+    .await;
+    fs.insert_tree(
+        "/worktrees/project/feature-a/project",
+        serde_json::json!({
+            ".git": "gitdir: /project/.git/worktrees/feature-a",
+            "src": {},
+        }),
+    )
+    .await;
+    fs.add_linked_worktree_for_repo(
+        Path::new("/project/.git"),
+        false,
+        git::repository::Worktree {
+            path: PathBuf::from("/worktrees/project/feature-a/project"),
+            ref_name: Some("refs/heads/feature-a".into()),
+            sha: "aaa".into(),
+            is_main: false,
+            is_bare: false,
+        },
+    )
+    .await;
+    cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));
+
+    let main_project = project::Project::test(fs.clone(), ["/project".as_ref()], cx).await;
+    let worktree_project = project::Project::test(
+        fs.clone(),
+        ["/worktrees/project/feature-a/project".as_ref()],
+        cx,
+    )
+    .await;
+
+    main_project
+        .update(cx, |project, cx| project.git_scans_complete(cx))
+        .await;
+    worktree_project
+        .update(cx, |project, cx| project.git_scans_complete(cx))
+        .await;
+
+    let (multi_workspace, cx) =
+        cx.add_window_view(|window, cx| MultiWorkspace::test_new(main_project.clone(), window, cx));
+    let _sidebar = setup_sidebar(&multi_workspace, cx);
+    let worktree_workspace = multi_workspace.update_in(cx, |multi_workspace, window, cx| {
+        multi_workspace.test_add_workspace(worktree_project.clone(), window, cx)
+    });
+    let worktree_panel = add_agent_panel(&worktree_workspace, cx);
+
+    save_thread_metadata(
+        acp::SessionId::new(Arc::from("main-thread")),
+        Some("Main Thread".into()),
+        chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 2, 0, 0, 0).unwrap(),
+        None,
+        None,
+        &main_project,
+        cx,
+    );
+
+    let worktree_folder_paths =
+        PathList::new(&[PathBuf::from("/worktrees/project/feature-a/project")]);
+    let draft_id = save_draft_metadata_with_main_paths(
+        Some("Worktree Draft".into()),
+        worktree_folder_paths.clone(),
+        PathList::new(&[PathBuf::from("/project")]),
+        chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 3, 0, 0, 0).unwrap(),
+        cx,
+    );
+
+    worktree_panel.update_in(cx, |panel, window, cx| {
+        panel.load_agent_thread(
+            Agent::Stub,
+            draft_id,
+            Some(worktree_folder_paths.clone()),
+            None,
+            false,
+            AgentThreadSource::AgentPanel,
+            window,
+            cx,
+        );
+    });
+    cx.run_until_parked();
+    let editor_text =
+        worktree_panel.read_with(cx, |panel, cx| panel.editor_text_if_in_memory(draft_id, cx));
+    assert_eq!(
+        editor_text,
+        Some(None),
+        "draft should be in memory with empty editor text before editing"
+    );
+
+    let message_editor = worktree_panel.read_with(cx, |panel, cx| {
+        panel
+            .active_thread_view(cx)
+            .expect("draft should be loaded in the agent panel")
+            .read(cx)
+            .message_editor
+            .clone()
+    });
+    message_editor.update_in(cx, |editor, window, cx| {
+        editor.set_text("keep this draft", window, cx);
+    });
+
+    let terminal_id = worktree_panel
+        .update_in(cx, |panel, window, cx| {
+            panel.insert_test_terminal("Dev Server", true, window, cx)
+        })
+        .expect("test terminal should be inserted");
+    cx.run_until_parked();
+    let live_blocks = worktree_panel.read_with(cx, |panel, cx| {
+        panel.draft_prompt_blocks_if_in_memory(draft_id, cx)
+    });
+    assert!(
+        matches!(
+            live_blocks.as_deref(),
+            Some([acp::ContentBlock::Text(text)]) if text.text == "keep this draft"
+        ),
+        "edited draft should still be readable from the panel after opening the terminal"
+    );
+
+    assert_eq!(
+        multi_workspace.read_with(cx, |multi_workspace, _| multi_workspace
+            .workspaces()
+            .count()),
+        2,
+        "should start with main and linked worktree workspaces"
+    );
+
+    worktree_panel.update(cx, |panel, cx| {
+        panel.emit_test_terminal_close(terminal_id, cx);
+    });
+    for _ in 0..4 {
+        cx.run_until_parked();
+    }
+
+    let terminal_metadata_deleted = cx.update(|_, cx| {
+        TerminalThreadMetadataStore::global(cx)
+            .read(cx)
+            .entry(terminal_id)
+            .is_none()
+    });
+    assert!(
+        terminal_metadata_deleted,
+        "terminal metadata should be deleted after close"
+    );
+    let unarchived_worktree_threads = cx.update(|_, cx| {
+        ThreadMetadataStore::global(cx)
+            .read(cx)
+            .entries_for_path(&worktree_folder_paths, None)
+            .count()
+    });
+    assert_eq!(
+        unarchived_worktree_threads, 1,
+        "edited draft should remain as a worktree thread reference"
+    );
+    assert!(
+        multi_workspace
+            .read_with(cx, |multi_workspace, cx| {
+                multi_workspace.workspace_for_paths(&worktree_folder_paths, None, cx)
+            })
+            .is_some(),
+        "linked worktree workspace should stay open while an edited draft references it"
+    );
+    assert!(
+        fs.is_dir(Path::new("/worktrees/project/feature-a/project"))
+            .await,
+        "linked worktree directory should remain on disk while an edited draft references it"
+    );
+}
+
+#[gpui::test]
+async fn test_archive_selected_draft_archives_linked_worktree_after_last_draft(
+    cx: &mut TestAppContext,
+) {
+    init_test(cx);
+
+    let fs = FakeFs::new(cx.executor());
+    fs.insert_tree(
+        "/project",
+        serde_json::json!({
+            ".git": {
+                "worktrees": {
+                    "feature-a": {
+                        "commondir": "../../",
+                        "HEAD": "ref: refs/heads/feature-a",
+                    },
+                },
+            },
+            "src": {},
+        }),
+    )
+    .await;
+    fs.insert_tree(
+        "/worktrees/project/feature-a/project",
+        serde_json::json!({
+            ".git": "gitdir: /project/.git/worktrees/feature-a",
+            "src": {},
+        }),
+    )
+    .await;
+    fs.add_linked_worktree_for_repo(
+        Path::new("/project/.git"),
+        false,
+        git::repository::Worktree {
+            path: PathBuf::from("/worktrees/project/feature-a/project"),
+            ref_name: Some("refs/heads/feature-a".into()),
+            sha: "aaa".into(),
+            is_main: false,
+            is_bare: false,
+        },
+    )
+    .await;
+    cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));
+
+    let main_project = project::Project::test(fs.clone(), ["/project".as_ref()], cx).await;
+    let worktree_project = project::Project::test(
+        fs.clone(),
+        ["/worktrees/project/feature-a/project".as_ref()],
+        cx,
+    )
+    .await;
+
+    main_project
+        .update(cx, |project, cx| project.git_scans_complete(cx))
+        .await;
+    worktree_project
+        .update(cx, |project, cx| project.git_scans_complete(cx))
+        .await;
+
+    let (multi_workspace, cx) =
+        cx.add_window_view(|window, cx| MultiWorkspace::test_new(main_project.clone(), window, cx));
+    let sidebar = setup_sidebar(&multi_workspace, cx);
+    let worktree_workspace = multi_workspace.update_in(cx, |multi_workspace, window, cx| {
+        multi_workspace.test_add_workspace(worktree_project.clone(), window, cx)
+    });
+    add_agent_panel(&worktree_workspace, cx);
+
+    save_thread_metadata(
+        acp::SessionId::new(Arc::from("main-thread")),
+        Some("Main Thread".into()),
+        chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 2, 0, 0, 0).unwrap(),
+        None,
+        None,
+        &main_project,
+        cx,
+    );
+
+    let worktree_folder_paths =
+        PathList::new(&[PathBuf::from("/worktrees/project/feature-a/project")]);
+    let first_draft_id = save_draft_metadata_with_main_paths(
+        Some("First Draft".into()),
+        worktree_folder_paths.clone(),
+        PathList::new(&[PathBuf::from("/project")]),
+        chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 3, 0, 0, 0).unwrap(),
+        cx,
+    );
+    let second_draft_id = save_draft_metadata_with_main_paths(
+        Some("Second Draft".into()),
+        worktree_folder_paths.clone(),
+        PathList::new(&[PathBuf::from("/project")]),
+        chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 4, 0, 0, 0).unwrap(),
+        cx,
+    );
+    cx.update(|_, cx| {
+        agent_ui::draft_prompt_store::write(
+            first_draft_id,
+            &[acp::ContentBlock::Text(acp::TextContent::new(
+                "first draft",
+            ))],
+            cx,
+        )
+    })
+    .await
+    .expect("first draft prompt should persist");
+    cx.update(|_, cx| {
+        agent_ui::draft_prompt_store::write(
+            second_draft_id,
+            &[acp::ContentBlock::Text(acp::TextContent::new(
+                "second draft",
+            ))],
+            cx,
+        )
+    })
+    .await
+    .expect("second draft prompt should persist");
+    sidebar.update(cx, |sidebar, cx| sidebar.update_entries(cx));
+    cx.run_until_parked();
+
+    let first_draft_index = sidebar.read_with(cx, |sidebar, _cx| {
+        sidebar
+            .contents
+            .entries
+            .iter()
+            .position(|entry| {
+                matches!(
+                    entry,
+                    ListEntry::Thread(thread) if thread.metadata.thread_id == first_draft_id
+                )
+            })
+            .expect("first draft should be visible in sidebar")
+    });
+    focus_sidebar(&sidebar, cx);
+    sidebar.update_in(cx, |sidebar, _window, _cx| {
+        sidebar.selection = Some(first_draft_index);
+    });
+    cx.dispatch_action(ArchiveSelectedThread);
+    for _ in 0..4 {
+        cx.run_until_parked();
+    }
+
+    let first_draft_metadata_deleted = cx.update(|_, cx| {
+        ThreadMetadataStore::global(cx)
+            .read(cx)
+            .entry(first_draft_id)
+            .is_none()
+    });
+    assert!(
+        first_draft_metadata_deleted,
+        "first discarded draft metadata should be deleted"
+    );
+    let second_draft_metadata_kept = cx.update(|_, cx| {
+        ThreadMetadataStore::global(cx)
+            .read(cx)
+            .entry(second_draft_id)
+            .is_some()
+    });
+    assert!(
+        second_draft_metadata_kept,
+        "remaining contentful draft should still block worktree archival"
+    );
+    assert!(
+        multi_workspace
+            .read_with(cx, |multi_workspace, cx| {
+                multi_workspace.workspace_for_paths(&worktree_folder_paths, None, cx)
+            })
+            .is_some(),
+        "linked worktree workspace should remain while another draft references it"
+    );
+    assert!(
+        fs.is_dir(Path::new("/worktrees/project/feature-a/project"))
+            .await,
+        "linked worktree directory should remain while another draft references it"
+    );
+
+    let second_draft_index = sidebar.read_with(cx, |sidebar, _cx| {
+        sidebar
+            .contents
+            .entries
+            .iter()
+            .position(|entry| {
+                matches!(
+                    entry,
+                    ListEntry::Thread(thread) if thread.metadata.thread_id == second_draft_id
+                )
+            })
+            .expect("second draft should be visible in sidebar")
+    });
+    sidebar.update_in(cx, |sidebar, _window, _cx| {
+        sidebar.selection = Some(second_draft_index);
+    });
+    cx.dispatch_action(ArchiveSelectedThread);
+    for _ in 0..8 {
+        cx.run_until_parked();
+    }
+
+    let second_draft_metadata_deleted = cx.update(|_, cx| {
+        ThreadMetadataStore::global(cx)
+            .read(cx)
+            .entry(second_draft_id)
+            .is_none()
+    });
+    assert!(
+        second_draft_metadata_deleted,
+        "last discarded draft metadata should be deleted"
+    );
+    assert!(
+        multi_workspace
+            .read_with(cx, |multi_workspace, cx| {
+                multi_workspace.workspace_for_paths(&worktree_folder_paths, None, cx)
+            })
+            .is_none(),
+        "linked worktree workspace should be removed after closing its last draft"
+    );
+    assert!(
+        !fs.is_dir(Path::new("/worktrees/project/feature-a/project"))
+            .await,
+        "linked worktree directory should be removed from disk after closing its last draft"
+    );
+}
+
+#[gpui::test]
+async fn test_archive_selected_draft_archives_closed_linked_worktree(cx: &mut TestAppContext) {
+    init_test(cx);
+
+    let fs = FakeFs::new(cx.executor());
+    fs.insert_tree(
+        "/project",
+        serde_json::json!({
+            ".git": {
+                "worktrees": {
+                    "feature-a": {
+                        "commondir": "../../",
+                        "HEAD": "ref: refs/heads/feature-a",
+                    },
+                },
+            },
+            "src": {},
+        }),
+    )
+    .await;
+    fs.insert_tree(
+        "/worktrees/project/feature-a/project",
+        serde_json::json!({
+            ".git": "gitdir: /project/.git/worktrees/feature-a",
+            "src": {},
+        }),
+    )
+    .await;
+    fs.add_linked_worktree_for_repo(
+        Path::new("/project/.git"),
+        false,
+        git::repository::Worktree {
+            path: PathBuf::from("/worktrees/project/feature-a/project"),
+            ref_name: Some("refs/heads/feature-a".into()),
+            sha: "aaa".into(),
+            is_main: false,
+            is_bare: false,
+        },
+    )
+    .await;
+    cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));
+
+    let main_project = project::Project::test(fs.clone(), ["/project".as_ref()], cx).await;
+    main_project
+        .update(cx, |project, cx| project.git_scans_complete(cx))
+        .await;
+
+    let (multi_workspace, cx) =
+        cx.add_window_view(|window, cx| MultiWorkspace::test_new(main_project.clone(), window, cx));
+    let sidebar = setup_sidebar(&multi_workspace, cx);
+
+    save_thread_metadata(
+        acp::SessionId::new(Arc::from("main-thread")),
+        Some("Main Thread".into()),
+        chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 2, 0, 0, 0).unwrap(),
+        None,
+        None,
+        &main_project,
+        cx,
+    );
+
+    let worktree_folder_paths =
+        PathList::new(&[PathBuf::from("/worktrees/project/feature-a/project")]);
+    let draft_id = save_draft_metadata_with_main_paths(
+        Some("Closed Worktree Draft".into()),
+        worktree_folder_paths.clone(),
+        PathList::new(&[PathBuf::from("/project")]),
+        chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 3, 0, 0, 0).unwrap(),
+        cx,
+    );
+    cx.update(|_, cx| {
+        agent_ui::draft_prompt_store::write(
+            draft_id,
+            &[acp::ContentBlock::Text(acp::TextContent::new(
+                "closed draft",
+            ))],
+            cx,
+        )
+    })
+    .await
+    .expect("draft prompt should persist");
+    sidebar.update(cx, |sidebar, cx| sidebar.update_entries(cx));
+    cx.run_until_parked();
+
+    let draft_index = sidebar.read_with(cx, |sidebar, _cx| {
+        sidebar
+            .contents
+            .entries
+            .iter()
+            .position(|entry| {
+                matches!(
+                    entry,
+                    ListEntry::Thread(thread) if thread.metadata.thread_id == draft_id
+                )
+            })
+            .expect("closed worktree draft should be visible in sidebar")
+    });
+    sidebar.read_with(cx, |sidebar, _cx| {
+        match &sidebar.contents.entries[draft_index] {
+            ListEntry::Thread(thread) => match &thread.workspace {
+                ThreadEntryWorkspace::Closed { folder_paths, .. } => {
+                    assert_eq!(folder_paths, &worktree_folder_paths);
+                }
+                ThreadEntryWorkspace::Open(_) => {
+                    panic!("linked worktree draft should start closed")
+                }
+            },
+            _ => panic!("expected draft row"),
+        }
+    });
+
+    focus_sidebar(&sidebar, cx);
+    sidebar.update_in(cx, |sidebar, _window, _cx| {
+        sidebar.selection = Some(draft_index);
+    });
+    cx.dispatch_action(ArchiveSelectedThread);
+    for _ in 0..8 {
+        cx.run_until_parked();
+    }
+
+    let draft_metadata_deleted = cx.update(|_, cx| {
+        ThreadMetadataStore::global(cx)
+            .read(cx)
+            .entry(draft_id)
+            .is_none()
+    });
+    assert!(
+        draft_metadata_deleted,
+        "discarded closed worktree draft metadata should be deleted"
+    );
+    assert!(
+        multi_workspace
+            .read_with(cx, |multi_workspace, cx| {
+                multi_workspace.workspace_for_paths(&worktree_folder_paths, None, cx)
+            })
+            .is_none(),
+        "temporary linked worktree workspace should be removed after discarding its last draft"
+    );
+    assert_eq!(
+        multi_workspace.read_with(cx, |multi_workspace, _| multi_workspace
+            .workspaces()
+            .count()),
+        1,
+        "discarding a closed linked worktree draft should leave only the main workspace"
+    );
+    assert!(
+        !fs.is_dir(Path::new("/worktrees/project/feature-a/project"))
+            .await,
+        "linked worktree directory should be removed from disk after discarding its last draft"
+    );
+}
+
 #[gpui::test]
 async fn test_terminal_close_event_closes_sidebar_terminal(cx: &mut TestAppContext) {
     let project = init_test_project_with_agent_panel("/my-project", cx).await;
@@ -2459,6 +3176,19 @@ async fn test_archive_selected_terminal_archives_closed_linked_worktree(cx: &mut
             store.save(metadata, cx);
         });
     });
+    let empty_draft_id = save_draft_metadata_with_main_paths(
+        None,
+        worktree_folder_paths.clone(),
+        PathList::new(&[PathBuf::from("/project")]),
+        chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 2, 0, 0, 0).unwrap(),
+        cx,
+    );
+    cx.update(|_, cx| {
+        assert!(
+            agent_ui::draft_prompt_store::read(empty_draft_id, cx).is_none(),
+            "empty draft should not have persisted prompt content"
+        );
+    });
     sidebar.update(cx, |sidebar, cx| sidebar.update_entries(cx));
     cx.run_until_parked();
 
@@ -2503,6 +3233,16 @@ async fn test_archive_selected_terminal_archives_closed_linked_worktree(cx: &mut
         terminal_metadata_deleted,
         "terminal metadata should be deleted after closing from the sidebar"
     );
+    let empty_draft_metadata_deleted = cx.update(|_, cx| {
+        ThreadMetadataStore::global(cx)
+            .read(cx)
+            .entry(empty_draft_id)
+            .is_none()
+    });
+    assert!(
+        empty_draft_metadata_deleted,
+        "empty draft metadata should be deleted before archiving the linked worktree"
+    );
     assert!(
         multi_workspace
             .read_with(cx, |multi_workspace, cx| {
@@ -2596,6 +3336,19 @@ async fn test_archive_selected_thread_archives_closed_linked_worktree(cx: &mut T
         &main_project,
         cx,
     );
+    let empty_draft_id = save_draft_metadata_with_main_paths(
+        None,
+        worktree_folder_paths.clone(),
+        PathList::new(&[PathBuf::from("/project")]),
+        chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 3, 0, 0, 0).unwrap(),
+        cx,
+    );
+    cx.update(|_, cx| {
+        assert!(
+            agent_ui::draft_prompt_store::read(empty_draft_id, cx).is_none(),
+            "empty draft should not have persisted prompt content"
+        );
+    });
     sidebar.update(cx, |sidebar, cx| sidebar.update_entries(cx));
     cx.run_until_parked();
 
@@ -2641,6 +3394,16 @@ async fn test_archive_selected_thread_archives_closed_linked_worktree(cx: &mut T
         Some(true),
         "thread metadata should remain archived after worktree archival"
     );
+    let empty_draft_metadata_deleted = cx.update(|_, cx| {
+        ThreadMetadataStore::global(cx)
+            .read(cx)
+            .entry(empty_draft_id)
+            .is_none()
+    });
+    assert!(
+        empty_draft_metadata_deleted,
+        "empty draft metadata should be deleted before archiving the linked worktree"
+    );
     assert!(
         multi_workspace
             .read_with(cx, |multi_workspace, cx| {
@@ -2663,6 +3426,127 @@ async fn test_archive_selected_thread_archives_closed_linked_worktree(cx: &mut T
     );
 }
 
+#[gpui::test]
+async fn test_archive_selected_thread_deletes_empty_draft_when_linked_worktree_has_no_archive_root(
+    cx: &mut TestAppContext,
+) {
+    init_test(cx);
+
+    let fs = FakeFs::new(cx.executor());
+    fs.insert_tree(
+        "/project",
+        serde_json::json!({
+            ".git": {},
+            "src": {},
+        }),
+    )
+    .await;
+    fs.set_branch_name(Path::new("/project/.git"), Some("main"));
+    fs.insert_branches(Path::new("/project/.git"), &["main", "feature-a"]);
+    fs.add_linked_worktree_for_repo(
+        Path::new("/project/.git"),
+        false,
+        git::repository::Worktree {
+            path: PathBuf::from("/external-worktree"),
+            ref_name: Some("refs/heads/feature-a".into()),
+            sha: "aaa".into(),
+            is_main: false,
+            is_bare: false,
+        },
+    )
+    .await;
+    cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));
+
+    let main_project = project::Project::test(fs.clone(), ["/project".as_ref()], cx).await;
+    main_project
+        .update(cx, |project, cx| project.git_scans_complete(cx))
+        .await;
+
+    let (multi_workspace, cx) =
+        cx.add_window_view(|window, cx| MultiWorkspace::test_new(main_project.clone(), window, cx));
+    let sidebar = setup_sidebar(&multi_workspace, cx);
+
+    let worktree_session_id = acp::SessionId::new(Arc::from("external-worktree-thread"));
+    let worktree_folder_paths = PathList::new(&[PathBuf::from("/external-worktree")]);
+    save_thread_metadata_with_main_paths(
+        "external-worktree-thread",
+        "External Worktree Thread",
+        worktree_folder_paths.clone(),
+        PathList::new(&[PathBuf::from("/project")]),
+        chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 1, 0, 0, 0).unwrap(),
+        cx,
+    );
+    save_thread_metadata(
+        acp::SessionId::new(Arc::from("main-thread")),
+        Some("Main Thread".into()),
+        chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 2, 0, 0, 0).unwrap(),
+        None,
+        None,
+        &main_project,
+        cx,
+    );
+    let empty_draft_id = save_draft_metadata_with_main_paths(
+        None,
+        worktree_folder_paths.clone(),
+        PathList::new(&[PathBuf::from("/project")]),
+        chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 3, 0, 0, 0).unwrap(),
+        cx,
+    );
+    sidebar.update(cx, |sidebar, cx| sidebar.update_entries(cx));
+    cx.run_until_parked();
+
+    let thread_index = sidebar.read_with(cx, |sidebar, _cx| {
+        sidebar
+            .contents
+            .entries
+            .iter()
+            .position(|entry| matches!(entry, ListEntry::Thread(thread) if thread.metadata.session_id.as_ref() == Some(&worktree_session_id)))
+            .expect("worktree thread should be visible in sidebar")
+    });
+    focus_sidebar(&sidebar, cx);
+    sidebar.update_in(cx, |sidebar, _window, _cx| {
+        sidebar.selection = Some(thread_index);
+    });
+    cx.dispatch_action(ArchiveSelectedThread);
+    for _ in 0..8 {
+        cx.run_until_parked();
+    }
+
+    let thread_archived = cx.update(|_, cx| {
+        ThreadMetadataStore::global(cx)
+            .read(cx)
+            .entry_by_session(&worktree_session_id)
+            .map(|thread| thread.archived)
+    });
+    assert_eq!(
+        thread_archived,
+        Some(true),
+        "thread metadata should remain archived after workspace removal"
+    );
+    let empty_draft_metadata_deleted = cx.update(|_, cx| {
+        ThreadMetadataStore::global(cx)
+            .read(cx)
+            .entry(empty_draft_id)
+            .is_none()
+    });
+    assert!(
+        empty_draft_metadata_deleted,
+        "empty draft metadata should be deleted when removing the linked worktree workspace"
+    );
+    assert!(
+        multi_workspace
+            .read_with(cx, |multi_workspace, cx| {
+                multi_workspace.workspace_for_paths(&worktree_folder_paths, None, cx)
+            })
+            .is_none(),
+        "linked worktree workspace should be removed after archiving its last thread"
+    );
+    assert!(
+        fs.is_dir(Path::new("/external-worktree")).await,
+        "external linked worktree directory should remain on disk when no archive root is produced"
+    );
+}
+
 #[gpui::test]
 async fn test_archive_selected_thread_closes_selected_agent_panel_terminal(
     cx: &mut TestAppContext,
@@ -12472,6 +13356,215 @@ async fn test_archive_mixed_workspace_closes_only_archived_worktree_items(cx: &m
     );
 }
 
+#[gpui::test]
+async fn test_discard_mixed_workspace_draft_closes_only_archived_worktree_items(
+    cx: &mut TestAppContext,
+) {
+    init_test(cx);
+    let fs = FakeFs::new(cx.executor());
+
+    fs.insert_tree(
+        "/main-repo",
+        serde_json::json!({
+            ".git": {
+                "worktrees": {
+                    "feature-b": {
+                        "commondir": "../../",
+                        "HEAD": "ref: refs/heads/feature-b",
+                    },
+                },
+            },
+            "src": {
+                "lib.rs": "pub fn hello() {}",
+            },
+        }),
+    )
+    .await;
+
+    fs.insert_tree(
+        "/worktrees/main-repo/feature-b/main-repo",
+        serde_json::json!({
+            ".git": "gitdir: /main-repo/.git/worktrees/feature-b",
+            "src": {
+                "main.rs": "fn main() { hello(); }",
+            },
+        }),
+    )
+    .await;
+
+    fs.add_linked_worktree_for_repo(
+        Path::new("/main-repo/.git"),
+        false,
+        git::repository::Worktree {
+            path: PathBuf::from("/worktrees/main-repo/feature-b/main-repo"),
+            ref_name: Some("refs/heads/feature-b".into()),
+            sha: "def".into(),
+            is_main: false,
+            is_bare: false,
+        },
+    )
+    .await;
+
+    cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));
+
+    let mixed_project = project::Project::test(
+        fs.clone(),
+        [
+            "/main-repo".as_ref(),
+            "/worktrees/main-repo/feature-b/main-repo".as_ref(),
+        ],
+        cx,
+    )
+    .await;
+
+    mixed_project
+        .update(cx, |project, cx| project.git_scans_complete(cx))
+        .await;
+
+    let (multi_workspace, cx) = cx
+        .add_window_view(|window, cx| MultiWorkspace::test_new(mixed_project.clone(), window, cx));
+    let sidebar = setup_sidebar(&multi_workspace, cx);
+    let workspace =
+        multi_workspace.read_with(cx, |multi_workspace, _| multi_workspace.workspace().clone());
+
+    let worktree_ids: Vec<(WorktreeId, Arc<Path>)> = workspace.read_with(cx, |workspace, cx| {
+        workspace
+            .project()
+            .read(cx)
+            .visible_worktrees(cx)
+            .map(|worktree| (worktree.read(cx).id(), worktree.read(cx).abs_path()))
+            .collect()
+    });
+
+    let main_repo_worktree_id = worktree_ids
+        .iter()
+        .find(|(_, path)| path.as_ref() == Path::new("/main-repo"))
+        .map(|(id, _)| *id)
+        .expect("should find main-repo worktree");
+
+    let feature_b_worktree_id = worktree_ids
+        .iter()
+        .find(|(_, path)| path.as_ref() == Path::new("/worktrees/main-repo/feature-b/main-repo"))
+        .map(|(id, _)| *id)
+        .expect("should find feature-b worktree");
+
+    let main_repo_path = project::ProjectPath {
+        worktree_id: main_repo_worktree_id,
+        path: Arc::from(rel_path("src/lib.rs")),
+    };
+    let feature_b_path = project::ProjectPath {
+        worktree_id: feature_b_worktree_id,
+        path: Arc::from(rel_path("src/main.rs")),
+    };
+
+    workspace
+        .update_in(cx, |workspace, window, cx| {
+            workspace.open_path(main_repo_path.clone(), None, true, window, cx)
+        })
+        .await
+        .expect("should open main-repo file");
+    workspace
+        .update_in(cx, |workspace, window, cx| {
+            workspace.open_path(feature_b_path.clone(), None, true, window, cx)
+        })
+        .await
+        .expect("should open feature-b file");
+
+    let folder_paths = PathList::new(&[
+        PathBuf::from("/main-repo"),
+        PathBuf::from("/worktrees/main-repo/feature-b/main-repo"),
+    ]);
+    let main_worktree_paths =
+        PathList::new(&[PathBuf::from("/main-repo"), PathBuf::from("/main-repo")]);
+    let draft_id = save_draft_metadata_with_main_paths(
+        Some("Mixed Workspace Draft".into()),
+        folder_paths,
+        main_worktree_paths,
+        chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 1, 0, 0, 0).unwrap(),
+        cx,
+    );
+    cx.update(|_, cx| {
+        agent_ui::draft_prompt_store::write(
+            draft_id,
+            &[acp::ContentBlock::Text(acp::TextContent::new(
+                "mixed workspace draft",
+            ))],
+            cx,
+        )
+    })
+    .await
+    .expect("draft prompt should persist");
+
+    sidebar.update(cx, |sidebar, cx| sidebar.update_entries(cx));
+    cx.run_until_parked();
+
+    let draft_index = sidebar.read_with(cx, |sidebar, _cx| {
+        sidebar
+            .contents
+            .entries
+            .iter()
+            .position(|entry| {
+                matches!(
+                    entry,
+                    ListEntry::Thread(thread) if thread.metadata.thread_id == draft_id
+                )
+            })
+            .expect("mixed workspace draft should be visible")
+    });
+
+    focus_sidebar(&sidebar, cx);
+    sidebar.update_in(cx, |sidebar, _window, _cx| {
+        sidebar.selection = Some(draft_index);
+    });
+    cx.dispatch_action(ArchiveSelectedThread);
+    for _ in 0..8 {
+        cx.run_until_parked();
+    }
+
+    assert_eq!(
+        multi_workspace.read_with(cx, |multi_workspace, _| multi_workspace
+            .workspaces()
+            .count()),
+        1,
+        "mixed workspace should be preserved"
+    );
+
+    let open_paths_after: Vec<project::ProjectPath> = workspace.read_with(cx, |workspace, cx| {
+        workspace
+            .panes()
+            .iter()
+            .flat_map(|pane| {
+                pane.read(cx)
+                    .items()
+                    .filter_map(|item| item.project_path(cx))
+            })
+            .collect()
+    });
+    assert!(
+        open_paths_after
+            .iter()
+            .any(|project_path| project_path.worktree_id == main_repo_worktree_id),
+        "main-repo file should still be open"
+    );
+    assert!(
+        !open_paths_after
+            .iter()
+            .any(|project_path| project_path.worktree_id == feature_b_worktree_id),
+        "feature-b file should have been closed"
+    );
+
+    let draft_metadata_deleted = cx.update(|_, cx| {
+        ThreadMetadataStore::global(cx)
+            .read(cx)
+            .entry(draft_id)
+            .is_none()
+    });
+    assert!(
+        draft_metadata_deleted,
+        "discarded draft metadata should be deleted"
+    );
+}
+
 #[test]
 fn test_worktree_info_branch_names_for_main_worktrees() {
     let folder_paths = PathList::new(&[PathBuf::from("/projects/myapp")]);
@@ -12715,6 +13808,164 @@ async fn test_remote_archive_thread_with_active_connection(
     );
 }
 
+#[gpui::test]
+async fn test_remote_linked_worktree_workspace_to_remove_uses_remote_connection(
+    cx: &mut TestAppContext,
+    server_cx: &mut TestAppContext,
+) {
+    init_test(cx);
+
+    cx.update(|cx| {
+        release_channel::init(semver::Version::new(0, 0, 0), cx);
+    });
+    server_cx.update(|cx| {
+        release_channel::init(semver::Version::new(0, 0, 0), cx);
+    });
+
+    let app_state = cx.update(|cx| {
+        let app_state = workspace::AppState::test(cx);
+        workspace::init(app_state.clone(), cx);
+        app_state
+    });
+
+    let server_fs = FakeFs::new(server_cx.executor());
+    server_fs
+        .insert_tree(
+            "/project",
+            serde_json::json!({
+                ".git": {},
+                "src": {},
+            }),
+        )
+        .await;
+    server_fs
+        .insert_tree(
+            "/external-worktree",
+            serde_json::json!({
+                ".git": "gitdir: /project/.git/worktrees/feature-a",
+                "src": {},
+            }),
+        )
+        .await;
+    server_fs.set_branch_name(Path::new("/project/.git"), Some("main"));
+    server_fs.insert_branches(Path::new("/project/.git"), &["main", "feature-a"]);
+    server_fs
+        .add_linked_worktree_for_repo(
+            Path::new("/project/.git"),
+            false,
+            git::repository::Worktree {
+                path: PathBuf::from("/external-worktree"),
+                ref_name: Some("refs/heads/feature-a".into()),
+                sha: "abc".into(),
+                is_main: false,
+                is_bare: false,
+            },
+        )
+        .await;
+
+    let (worktree_project, _headless, remote_connection) = start_remote_project(
+        &server_fs,
+        Path::new("/external-worktree"),
+        &app_state,
+        None,
+        cx,
+        server_cx,
+    )
+    .await;
+    worktree_project
+        .update(cx, |project, cx| project.git_scans_complete(cx))
+        .await;
+    cx.run_until_parked();
+
+    cx.update(|cx| <dyn fs::Fs>::set_global(app_state.fs.clone(), cx));
+
+    let (multi_workspace, cx) = cx.add_window_view(|window, cx| {
+        MultiWorkspace::test_new(worktree_project.clone(), window, cx)
+    });
+    let sidebar = setup_sidebar(&multi_workspace, cx);
+
+    let worktree_session_id = acp::SessionId::new(Arc::from("remote-worktree-thread"));
+    let worktree_folder_paths = PathList::new(&[PathBuf::from("/external-worktree")]);
+    let main_folder_paths = PathList::new(&[PathBuf::from("/project")]);
+    let worktree_thread_id = ThreadId::new();
+    cx.update(|_window, cx| {
+        let metadata = ThreadMetadata {
+            thread_id: worktree_thread_id,
+            session_id: Some(worktree_session_id.clone()),
+            agent_id: agent::ZED_AGENT_ID.clone(),
+            title: Some("Remote Worktree Thread".into()),
+            title_override: None,
+            updated_at: chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 1, 0, 0, 0).unwrap(),
+            created_at: None,
+            interacted_at: None,
+            worktree_paths: WorktreePaths::from_path_lists(
+                main_folder_paths,
+                worktree_folder_paths.clone(),
+            )
+            .unwrap(),
+            archived: false,
+            remote_connection: Some(remote_connection.clone()),
+        };
+        ThreadMetadataStore::global(cx).update(cx, |store, cx| store.save(metadata, cx));
+    });
+    cx.run_until_parked();
+
+    assert!(
+        multi_workspace
+            .read_with(cx, |multi_workspace, cx| {
+                multi_workspace.workspace_for_paths(
+                    &worktree_folder_paths,
+                    Some(&remote_connection),
+                    cx,
+                )
+            })
+            .is_some(),
+        "remote linked-worktree workspace should be open before archiving"
+    );
+    assert!(
+        multi_workspace
+            .read_with(cx, |multi_workspace, cx| {
+                multi_workspace.workspace_for_paths(&worktree_folder_paths, None, cx)
+            })
+            .is_none(),
+        "the test must exercise a remote-only workspace lookup"
+    );
+    assert_ne!(
+        multi_workspace
+            .read_with(cx, |multi_workspace, cx| {
+                multi_workspace.workspace().read(cx).project_group_key(cx)
+            })
+            .path_list(),
+        &worktree_folder_paths,
+        "remote workspace must be classified as a linked worktree under the main project"
+    );
+
+    let workspace_to_remove = sidebar.read_with(cx, |sidebar, cx| {
+        sidebar
+            .linked_worktree_workspace_to_remove(
+                &worktree_folder_paths,
+                Some(&remote_connection),
+                Some(worktree_thread_id),
+                None,
+                &[],
+                cx,
+            )
+            .map(|workspace| workspace.entity_id())
+    });
+    let active_workspace_id = multi_workspace.read_with(cx, |multi_workspace, _cx| {
+        multi_workspace.workspace().entity_id()
+    });
+    assert_eq!(
+        workspace_to_remove,
+        Some(active_workspace_id),
+        "archive helper should resolve the remote linked-worktree workspace"
+    );
+    assert!(
+        server_fs.is_dir(Path::new("/external-worktree")).await,
+        "direct helper check should not remove the linked worktree from disk"
+    );
+}
+
 #[gpui::test]
 async fn test_remote_archive_thread_with_disconnected_remote(
     cx: &mut TestAppContext,

From be0fc7fdf5d626daa2f75af355ea45590717141f Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Tue, 19 May 2026 18:12:44 -0300
Subject: [PATCH 042/105] Add settings UI page for skills (#57101)

Closes AI-267

This PR adds a skills subpage in the settings UI, where we display
global skills in the user tab and project skills in the corresponding
project tab. The approach taken here was the simplest one out of the
possible avenues we could've taken to implement this (which would
possibly require bigger refactors), given this is potentially the very
first page in the settings UI where we're displaying stuff that does not
correspond to data available in the `settings.json`.

Important to note that a major limitation of the global approach is that
it's dependent on the native agent having loaded the skill index,
meaning there's an edge case where, if you open the settings UI _before_
having opened the agent panel, you won't immediately see the available
skills. Something to discuss but that it felt like a viable option for a
first ship.

Release Notes:

- Agent: Added a skills section to the settings UI.
---
 Cargo.lock                                   |   1 +
 crates/agent/src/agent.rs                    |  55 +++++-
 crates/agent_skills/agent_skills.rs          |  18 ++
 crates/settings_ui/Cargo.toml                |   1 +
 crates/settings_ui/src/page_data.rs          |  11 +-
 crates/settings_ui/src/pages.rs              |   2 +
 crates/settings_ui/src/pages/skills_setup.rs | 186 +++++++++++++++++++
 7 files changed, 271 insertions(+), 3 deletions(-)
 create mode 100644 crates/settings_ui/src/pages/skills_setup.rs

diff --git a/Cargo.lock b/Cargo.lock
index c9f821f7f17..bc935d54f76 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -16235,6 +16235,7 @@ version = "0.1.0"
 dependencies = [
  "agent",
  "agent_settings",
+ "agent_skills",
  "anyhow",
  "audio",
  "codestral",
diff --git a/crates/agent/src/agent.rs b/crates/agent/src/agent.rs
index ffe24590169..09a13b38818 100644
--- a/crates/agent/src/agent.rs
+++ b/crates/agent/src/agent.rs
@@ -31,8 +31,9 @@ use acp_thread::{
 };
 use agent_client_protocol::schema as acp;
 use agent_skills::{
-    MAX_SKILL_DESCRIPTIONS_SIZE, Skill, SkillLoadError, SkillScopeId, SkillSource, SkillSummary,
-    builtin_skills, global_skills_dir, load_skills_from_directory, project_skills_relative_path,
+    MAX_SKILL_DESCRIPTIONS_SIZE, ProjectSkillGroup, Skill, SkillIndex, SkillLoadError,
+    SkillScopeId, SkillSource, SkillSummary, builtin_skills, global_skills_dir,
+    load_skills_from_directory, project_skills_relative_path,
 };
 use anyhow::{Context as _, Result, anyhow};
 use chrono::{DateTime, Utc};
@@ -369,6 +370,10 @@ impl NativeAgent {
                 subscriptions.push(cx.subscribe(prompt_store, Self::handle_prompts_updated_event))
             }
 
+            if !cx.has_global::<SkillIndex>() {
+                cx.set_global(SkillIndex::default());
+            }
+
             Self {
                 sessions: HashMap::default(),
                 pending_sessions: HashMap::default(),
@@ -796,6 +801,7 @@ impl NativeAgent {
                 // the available commands) can change without affecting the
                 // skill error list.
                 this.update_available_commands_for_project(project_id, cx);
+                this.publish_skill_index(cx);
             })?;
         }
 
@@ -1213,6 +1219,50 @@ impl NativeAgent {
         }
     }
 
+    fn publish_skill_index(&self, cx: &mut Context<Self>) {
+        let mut global_skills = Vec::new();
+        let mut project_groups: Vec<ProjectSkillGroup> = Vec::new();
+        let mut seen_global = false;
+
+        for state in self.projects.values() {
+            for skill in state.skills.iter() {
+                match &skill.source {
+                    SkillSource::BuiltIn => {}
+                    SkillSource::Global => {
+                        if !seen_global {
+                            global_skills.push(skill.clone());
+                        }
+                    }
+                    SkillSource::ProjectLocal {
+                        worktree_id,
+                        worktree_root_name,
+                    } => {
+                        if let Some(group) = project_groups
+                            .iter_mut()
+                            .find(|g| g.worktree_id == *worktree_id)
+                        {
+                            group.skills.push(skill.clone());
+                        } else {
+                            project_groups.push(ProjectSkillGroup {
+                                worktree_id: *worktree_id,
+                                worktree_root_name: SharedString::from(worktree_root_name.clone()),
+                                skills: vec![skill.clone()],
+                            });
+                        }
+                    }
+                }
+            }
+            if !global_skills.is_empty() {
+                seen_global = true;
+            }
+        }
+
+        cx.set_global(SkillIndex {
+            global_skills,
+            project_skills: project_groups,
+        });
+    }
+
     fn update_available_commands_for_project(&self, project_id: EntityId, cx: &mut Context<Self>) {
         let available_commands =
             Self::build_available_commands_for_project(self.projects.get(&project_id), cx);
@@ -1450,6 +1500,7 @@ impl NativeAgent {
         let has_remaining = self.sessions.values().any(|s| s.project_id == project_id);
         if !has_remaining {
             self.projects.remove(&project_id);
+            self.publish_skill_index(cx);
         }
 
         session.pending_save
diff --git a/crates/agent_skills/agent_skills.rs b/crates/agent_skills/agent_skills.rs
index 8f185ff4ad9..2b37d88c649 100644
--- a/crates/agent_skills/agent_skills.rs
+++ b/crates/agent_skills/agent_skills.rs
@@ -2,6 +2,7 @@ use anyhow::{Context as _, Result};
 use const_format::concatcp;
 use fs::Fs;
 use futures::StreamExt;
+use gpui::{Global, SharedString};
 use serde::{Deserialize, Serialize};
 use std::io::{self, Read};
 use std::path::{Path, PathBuf};
@@ -157,6 +158,23 @@ impl SkillSource {
     }
 }
 
+/// App-wide index of loaded skills, published by NativeAgent and read
+/// by any UI that needs to display the skill list (e.g. Settings UI).
+#[derive(Default)]
+pub struct SkillIndex {
+    pub global_skills: Vec<Skill>,
+    pub project_skills: Vec<ProjectSkillGroup>,
+}
+
+#[derive(Clone)]
+pub struct ProjectSkillGroup {
+    pub worktree_id: SkillScopeId,
+    pub worktree_root_name: SharedString,
+    pub skills: Vec<Skill>,
+}
+
+impl Global for SkillIndex {}
+
 /// Just the frontmatter, used for parsing
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SkillMetadata {
diff --git a/crates/settings_ui/Cargo.toml b/crates/settings_ui/Cargo.toml
index d6865a4906b..ee725c0a1d9 100644
--- a/crates/settings_ui/Cargo.toml
+++ b/crates/settings_ui/Cargo.toml
@@ -18,6 +18,7 @@ test-support = []
 [dependencies]
 agent.workspace = true
 agent_settings.workspace = true
+agent_skills.workspace = true
 anyhow.workspace = true
 audio.workspace = true
 component.workspace = true
diff --git a/crates/settings_ui/src/page_data.rs b/crates/settings_ui/src/page_data.rs
index eafd7ed93bb..327f64b7dc5 100644
--- a/crates/settings_ui/src/page_data.rs
+++ b/crates/settings_ui/src/page_data.rs
@@ -13,7 +13,7 @@ use crate::{
     ActionLink, DynamicItem, PROJECT, SettingField, SettingItem, SettingsFieldMetadata,
     SettingsPage, SettingsPageItem, SubPageLink, USER, active_language, all_language_names,
     pages::{
-        open_audio_test_window, render_edit_prediction_setup_page,
+        open_audio_test_window, render_edit_prediction_setup_page, render_skills_setup_page,
         render_tool_permissions_setup_page,
     },
 };
@@ -7484,6 +7484,15 @@ fn ai_page(cx: &App) -> SettingsPage {
     fn agent_configuration_section(_cx: &App) -> Box<[SettingsPageItem]> {
         let mut items = vec![
             SettingsPageItem::SectionHeader("Agent Configuration"),
+            SettingsPageItem::SubPageLink(SubPageLink {
+                title: "Skills".into(),
+                r#type: Default::default(),
+                json_path: None,
+                description: Some("View and manage agent skills installed globally or in project worktrees.".into()),
+                in_json: false,
+                files: USER | PROJECT,
+                render: render_skills_setup_page,
+            }),
             SettingsPageItem::SubPageLink(SubPageLink {
                 title: "Tool Permissions".into(),
                 r#type: Default::default(),
diff --git a/crates/settings_ui/src/pages.rs b/crates/settings_ui/src/pages.rs
index 4a69069148e..f2f8dab3c4c 100644
--- a/crates/settings_ui/src/pages.rs
+++ b/crates/settings_ui/src/pages.rs
@@ -2,6 +2,7 @@ mod audio_input_output_setup;
 mod audio_test_window;
 mod edit_prediction_provider_setup;
 mod feature_flags;
+mod skills_setup;
 mod tool_permissions_setup;
 
 pub(crate) use audio_input_output_setup::{
@@ -10,6 +11,7 @@ pub(crate) use audio_input_output_setup::{
 pub(crate) use audio_test_window::open_audio_test_window;
 pub(crate) use edit_prediction_provider_setup::render_edit_prediction_setup_page;
 pub(crate) use feature_flags::render_feature_flags_page;
+pub(crate) use skills_setup::render_skills_setup_page;
 pub(crate) use tool_permissions_setup::render_tool_permissions_setup_page;
 
 pub use tool_permissions_setup::{
diff --git a/crates/settings_ui/src/pages/skills_setup.rs b/crates/settings_ui/src/pages/skills_setup.rs
new file mode 100644
index 00000000000..e3ea3bb548c
--- /dev/null
+++ b/crates/settings_ui/src/pages/skills_setup.rs
@@ -0,0 +1,186 @@
+use agent_skills::{Skill, SkillIndex};
+use fs::RemoveOptions;
+use gpui::{Action as _, ScrollHandle, SharedString, prelude::*};
+
+use ui::{Divider, Tooltip, prelude::*};
+use util::ResultExt as _;
+
+use crate::{SettingsUiFile, SettingsWindow};
+
+pub(crate) fn render_skills_setup_page(
+    settings_window: &SettingsWindow,
+    scroll_handle: &ScrollHandle,
+    _window: &mut Window,
+    cx: &mut Context<SettingsWindow>,
+) -> AnyElement {
+    let skill_index = cx.try_global::<SkillIndex>();
+
+    // Pick skills that match the current settings file tab:
+    // - User tab → global skills only
+    // - Project tab → project-local skills for that worktree only
+    let skills: Vec<Skill> = match &settings_window.current_file {
+        SettingsUiFile::User => skill_index
+            .map(|idx| idx.global_skills.clone())
+            .unwrap_or_default(),
+        SettingsUiFile::Project((worktree_id, _)) => {
+            let wt_id = usize::from(*worktree_id);
+            skill_index
+                .and_then(|idx| {
+                    idx.project_skills
+                        .iter()
+                        .find(|g| g.worktree_id.0 == wt_id)
+                        .map(|g| g.skills.clone())
+                })
+                .unwrap_or_default()
+        }
+        _ => Vec::new(),
+    };
+
+    v_flex()
+        .id("skills-page")
+        .size_full()
+        .pt_2p5()
+        .px_8()
+        .pb_16()
+        .map(|this| {
+            if skills.is_empty() {
+                let message = match &settings_window.current_file {
+                    SettingsUiFile::User => "No global skills installed.",
+                    SettingsUiFile::Project(_) => "No project skills found.",
+                    _ => "No skills available for this context.",
+                };
+                let original_window = settings_window.original_window;
+                this.items_center().justify_center().child(
+                    v_flex()
+                        .items_center()
+                        .gap_2()
+                        .child(Label::new(message).color(Color::Muted))
+                        .child(
+                            Button::new("open-agent-panel", "Create with Agent")
+                                .tab_index(0_isize)
+                                .style(ButtonStyle::Outlined)
+                                .end_icon(
+                                    Icon::new(IconName::ArrowUpRight)
+                                        .size(IconSize::Small)
+                                        .color(Color::Muted),
+                                )
+                                .on_click(cx.listener(move |_this, _event, window, cx| {
+                                    let Some(original_window) = original_window else {
+                                        return;
+                                    };
+                                    original_window
+                                        .update(cx, |_workspace, original_window, cx| {
+                                            original_window.dispatch_action(
+                                                zed_actions::assistant::ToggleFocus.boxed_clone(),
+                                                cx,
+                                            );
+                                            original_window.activate_window();
+                                        })
+                                        .log_err();
+                                    window.remove_window();
+                                })),
+                        ),
+                )
+            } else {
+                this.track_scroll(scroll_handle)
+                    .overflow_y_scroll()
+                    .children(skills.iter().enumerate().flat_map(|(i, skill)| {
+                        let mut elements: Vec<AnyElement> = vec![render_skill_row(skill, cx)];
+                        if i + 1 < skills.len() {
+                            elements.push(Divider::horizontal().into_any_element());
+                        }
+                        elements
+                    }))
+            }
+        })
+        .into_any_element()
+}
+
+fn render_skill_row(skill: &Skill, cx: &mut Context<SettingsWindow>) -> AnyElement {
+    let skill_file_path = skill.skill_file_path.clone();
+    let directory_path = skill.directory_path.clone();
+
+    h_flex()
+        .w_full()
+        .justify_between()
+        .py_2p5()
+        .gap_4()
+        .child(
+            v_flex()
+                .gap_0p5()
+                .min_w_0()
+                .flex_1()
+                .child(Label::new(skill.name.clone()))
+                .child(
+                    Label::new(skill.description.clone())
+                        .size(LabelSize::Small)
+                        .color(Color::Muted),
+                ),
+        )
+        .child(
+            h_flex()
+                .gap_2()
+                .child(
+                    IconButton::new(
+                        SharedString::from(format!("delete-{}", skill.name)),
+                        IconName::Trash,
+                    )
+                    .tab_index(0_isize)
+                    .icon_size(IconSize::Small)
+                    .tooltip(Tooltip::text("Delete Skill"))
+                    .on_click(cx.listener(
+                        move |_this, _event, _window, cx| {
+                            let directory_path = directory_path.clone();
+                            let app_state = workspace::AppState::global(cx);
+                            let fs = app_state.fs.clone();
+                            cx.spawn(async move |_this, _cx| {
+                                fs.remove_dir(
+                                    &directory_path,
+                                    RemoveOptions {
+                                        recursive: true,
+                                        ignore_if_not_exists: true,
+                                    },
+                                )
+                                .await
+                                .log_err();
+                            })
+                            .detach();
+                        },
+                    )),
+                )
+                .child(
+                    Button::new(SharedString::from(format!("open-{}", skill.name)), "Open")
+                        .tab_index(0_isize)
+                        .style(ButtonStyle::OutlinedGhost)
+                        .size(ButtonSize::Medium)
+                        .end_icon(
+                            Icon::new(IconName::ArrowUpRight)
+                                .size(IconSize::Small)
+                                .color(Color::Muted),
+                        )
+                        .on_click(cx.listener(move |settings_window, _event, window, cx| {
+                            let skill_file_path = skill_file_path.clone();
+                            let Some(original_window) = settings_window.original_window else {
+                                return;
+                            };
+                            original_window
+                                .update(cx, |multi_workspace, original_window, cx| {
+                                    let workspace = multi_workspace.workspace().clone();
+                                    workspace.update(cx, |workspace, cx| {
+                                        workspace
+                                            .open_abs_path(
+                                                skill_file_path,
+                                                Default::default(),
+                                                original_window,
+                                                cx,
+                                            )
+                                            .detach_and_log_err(cx);
+                                    });
+                                })
+                                .log_err();
+                            window.remove_window();
+                        })),
+                ),
+        )
+        .into_any_element()
+}

From a11af2049536785fe81322612c632951a5fc0a64 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Tue, 19 May 2026 17:31:34 -0400
Subject: [PATCH 043/105] Disable auto watch when leaving a call (#57196)

Auto watch's lifespan should be tied to that of the call and it should
not be assumed the user wants to have this on indefinitely (until app
restart), as it's more of a niche feature. This PR disables it when the
user leaves a call.

Self-Review Checklist:

- [X] I've reviewed my own diff for quality, security, and reliability
- [X] Unsafe blocks (if any) have justifying comments
- [X] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [X] Tests cover the new/changed behavior
- [X] Performance impact has been considered and is acceptable

Release Notes:

- N/A
---
 crates/call/src/call_impl/mod.rs              |  1 +
 .../tests/integration/auto_watch_tests.rs     | 42 +++++++++++++++++++
 crates/workspace/src/workspace.rs             |  7 ++++
 3 files changed, 50 insertions(+)

diff --git a/crates/call/src/call_impl/mod.rs b/crates/call/src/call_impl/mod.rs
index 2dba55134a1..6b87c4d8555 100644
--- a/crates/call/src/call_impl/mod.rs
+++ b/crates/call/src/call_impl/mod.rs
@@ -222,6 +222,7 @@ impl AnyActiveCall for ActiveCallEntity {
                     room::Event::LocalScreenShareStopped => {
                         Some(ActiveCallEvent::LocalScreenShareStopped)
                     }
+                    room::Event::RoomLeft { .. } => Some(ActiveCallEvent::RoomLeft),
                     _ => None,
                 };
                 if let Some(event) = mapped {
diff --git a/crates/collab/tests/integration/auto_watch_tests.rs b/crates/collab/tests/integration/auto_watch_tests.rs
index f119e1a4af4..9a1a29c7ead 100644
--- a/crates/collab/tests/integration/auto_watch_tests.rs
+++ b/crates/collab/tests/integration/auto_watch_tests.rs
@@ -430,6 +430,48 @@ async fn test_auto_watch_is_disabled_when_following_collaborator(
     });
 }
 
+#[gpui::test]
+async fn test_auto_watch_is_disabled_when_leaving_call(
+    executor: BackgroundExecutor,
+    user_a: &mut TestAppContext,
+    user_b: &mut TestAppContext,
+    user_c: &mut TestAppContext,
+) {
+    let mut server = TestServer::start(executor.clone()).await;
+    let setup = setup_auto_watch_test(&mut server, user_a, user_b, user_c).await;
+    let (workspace_a, user_a) = setup
+        .client_a
+        .build_workspace(&setup.user_a_project, user_a);
+
+    workspace_a.update_in(user_a, |workspace, window, cx| {
+        workspace.toggle_auto_watch(window, cx);
+    });
+    executor.run_until_parked();
+
+    workspace_a.update(user_a, |workspace, _cx| {
+        assert_eq!(
+            *workspace.auto_watch_state(),
+            AutoWatch::Active { watched_peer: None },
+            "auto-watch should be enabled after toggling on"
+        );
+    });
+
+    let active_call_a = user_a.read(ActiveCall::global);
+    active_call_a
+        .update(user_a, |call, cx| call.hang_up(cx))
+        .await
+        .unwrap();
+    executor.run_until_parked();
+
+    workspace_a.update(user_a, |workspace, _cx| {
+        assert_eq!(
+            *workspace.auto_watch_state(),
+            AutoWatch::Off,
+            "auto-watch should be off after leaving the call"
+        );
+    });
+}
+
 #[track_caller]
 fn assert_no_screen_share_tabs_exist(workspace: &Workspace, message: &str, cx: &App) {
     let has_shared_screen_tab = workspace
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 0f529fc9362..b3bafd0bb6b 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -6685,6 +6685,12 @@ impl Workspace {
             ActiveCallEvent::LocalScreenShareStopped => {
                 self.handle_auto_watch_local_share_stopped(window, cx);
             }
+            ActiveCallEvent::RoomLeft => {
+                if self.auto_watch.enabled() {
+                    self.auto_watch = AutoWatch::Off;
+                    cx.notify();
+                }
+            }
         }
     }
 
@@ -8136,6 +8142,7 @@ pub enum ActiveCallEvent {
     RemoteVideoTracksChanged { participant_id: PeerId },
     LocalScreenShareStarted,
     LocalScreenShareStopped,
+    RoomLeft,
 }
 
 fn leader_border_for_pane(

From 7b6be29669b9112b2fdb0eea6171423b9d4dd49f Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Tue, 19 May 2026 23:43:35 +0200
Subject: [PATCH 044/105] linux: Bundle libstdc++.so for release (#57132)

Self-Review Checklist:

- [ ] I've reviewed my own diff for quality, security, and reliability
- [ ] Unsafe blocks (if any) have justifying comments
- [ ] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [ ] Tests cover the new/changed behavior
- [ ] Performance impact has been considered and is acceptable

Closes https://github.com/zed-industries/zed/issues/57073

Release Notes:

- Fixed running Zed on Ubuntu 20.04 installed via the installer by
bundling the required `libstdc++.so`.
---
 script/bundle-linux | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/script/bundle-linux b/script/bundle-linux
index 3487feaf32b..b510365acb4 100755
--- a/script/bundle-linux
+++ b/script/bundle-linux
@@ -151,10 +151,12 @@ cp "${target_dir}/${target_triple}/release/zed" "${zed_dir}/libexec/zed-editor"
 cp "${target_dir}/${target_triple}/release/cli" "${zed_dir}/bin/zed"
 
 # Libs
+# Bundle libstdc++ so older supported systems can run binaries built with our
+# toolchain even when their system libstdc++.so.6 lacks required GLIBCXX symbols.
 find_libs() {
     ldd ${target_dir}/${target_triple}/release/zed |\
         cut -d' ' -f3 |\
-        grep -v '\<\(libstdc++.so\|libc.so\|libgcc_s.so\|libm.so\|libpthread.so\|libdl.so\|libasound.so\)'
+        grep -v '\<\(libc.so\|libgcc_s.so\|libm.so\|libpthread.so\|libdl.so\|libasound.so\)'
 }
 
 mkdir -p "${zed_dir}/lib"

From 1d207b02e01a06d600df308fbba6e4593c60299a Mon Sep 17 00:00:00 2001
From: Tom Zaspel <40226087+tzabbi@users.noreply.github.com>
Date: Tue, 19 May 2026 23:57:50 +0200
Subject: [PATCH 045/105] docs: Update Tree-sitter reference in OpenTofu and
 Terraform languages (#57168)

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)

Release Notes:

- N/A
---
 docs/src/languages/opentofu.md  | 2 +-
 docs/src/languages/terraform.md | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/src/languages/opentofu.md b/docs/src/languages/opentofu.md
index 7809099c055..e6bcdd2c3ef 100644
--- a/docs/src/languages/opentofu.md
+++ b/docs/src/languages/opentofu.md
@@ -7,7 +7,7 @@ description: "Configure OpenTofu language support in Zed, including language ser
 
 OpenTofu support is available through the [OpenTofu extension](https://github.com/ashpool37/zed-extension-opentofu).
 
-- Tree-sitter: [MichaHoffmann/tree-sitter-hcl](https://github.com/MichaHoffmann/tree-sitter-hcl)
+- Tree-sitter: [tree-sitter-grammars/tree-sitter-hcl](https://github.com/tree-sitter-grammars/tree-sitter-hcl)
 - Language Server: [opentofu/tofu-ls](https://github.com/opentofu/tofu-ls)
 
 ## Configuration
diff --git a/docs/src/languages/terraform.md b/docs/src/languages/terraform.md
index a7f87d20f46..a7e12b68187 100644
--- a/docs/src/languages/terraform.md
+++ b/docs/src/languages/terraform.md
@@ -7,7 +7,7 @@ description: "Configure Terraform language support in Zed, including language se
 
 Terraform support is available through the [Terraform extension](https://github.com/zed-extensions/terraform).
 
-- Tree-sitter: [MichaHoffmann/tree-sitter-hcl](https://github.com/MichaHoffmann/tree-sitter-hcl)
+- Tree-sitter: [tree-sitter-grammars/tree-sitter-hcl](https://github.com/tree-sitter-grammars/tree-sitter-hcl)
 - Language Server: [hashicorp/terraform-ls](https://github.com/hashicorp/terraform-ls)
 
 ## Configuration

From d42edc15f9868f38bea566faabe92d0bb16a3501 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Helmer=20Nordstr=C3=B6m?=
 <122628613+Helmutt03@users.noreply.github.com>
Date: Wed, 20 May 2026 00:03:01 +0200
Subject: [PATCH 046/105] grammars: Add `runnables.scm` for C++ (#57161)

Added a runnables.scm for cpp grammar so that tasks can be made with the
play button. It is already implemented for C.
---
 crates/grammars/src/cpp/runnables.scm | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 crates/grammars/src/cpp/runnables.scm

diff --git a/crates/grammars/src/cpp/runnables.scm b/crates/grammars/src/cpp/runnables.scm
new file mode 100644
index 00000000000..fe540534793
--- /dev/null
+++ b/crates/grammars/src/cpp/runnables.scm
@@ -0,0 +1,6 @@
+; Tag the main function
+((function_definition
+  declarator: (function_declarator
+    declarator: (identifier) @run)) @_cpp-main
+  (#eq? @run "main")
+  (#set! tag cpp-main))

From 952119de41c420a2da104928dbce6f65804385d5 Mon Sep 17 00:00:00 2001
From: Mikayla Maki <mikayla@zed.dev>
Date: Tue, 19 May 2026 17:05:34 -0700
Subject: [PATCH 047/105] Fix window crash (#57203)

Closes ZED-86Q

Fixes this (rare) crash by making entity creation via a window context
infallible.

The shape of the result is a bit clunky due to the type signatures
involved. The real solution is to remove AsyncWindowContext entirely and
move it's fallible APIs into WindowHandle, but until then this will give
you a simple starting point.

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Release Notes:

- N/A
---
 crates/gpui/src/app/async_context.rs | 39 ++++++++++++++++++++--------
 1 file changed, 28 insertions(+), 11 deletions(-)

diff --git a/crates/gpui/src/app/async_context.rs b/crates/gpui/src/app/async_context.rs
index be917764f43..6c5246f33d0 100644
--- a/crates/gpui/src/app/async_context.rs
+++ b/crates/gpui/src/app/async_context.rs
@@ -378,12 +378,21 @@ impl AppContext for AsyncWindowContext {
     where
         T: 'static,
     {
-        // Associate the new entity with our captured window so that
-        // `with_window` can resolve a dispatch target before the entity has
-        // been rendered.
-        self.app
-            .update_window(self.window, |_, _, cx| cx.new(build_entity))
-            .expect("window was unexpectedly closed")
+        let mut build_entity = Some(build_entity);
+        match self.app.update_window(self.window, |_, _, cx| {
+            cx.new(
+                build_entity
+                    .take()
+                    .expect("build_entity is taken exactly once"),
+            )
+        }) {
+            Ok(entity) => entity,
+            Err(_) => self.app.new(
+                build_entity
+                    .take()
+                    .expect("update_window returned Err without invoking the closure"),
+            ),
+        }
     }
 
     fn reserve_entity<T: 'static>(&mut self) -> Reservation<T> {
@@ -395,11 +404,19 @@ impl AppContext for AsyncWindowContext {
         reservation: Reservation<T>,
         build_entity: impl FnOnce(&mut Context<T>) -> T,
     ) -> Entity<T> {
-        self.app
-            .update_window(self.window, |_, _, cx| {
-                cx.insert_entity(reservation, build_entity)
-            })
-            .expect("window was unexpectedly closed")
+        let mut args = Some((reservation, build_entity));
+        match self.app.update_window(self.window, |_, _, cx| {
+            let (reservation, build_entity) = args.take().expect("args are taken exactly once");
+            cx.insert_entity(reservation, build_entity)
+        }) {
+            Ok(entity) => entity,
+            Err(_) => {
+                let (reservation, build_entity) = args
+                    .take()
+                    .expect("update_window returned Err without invoking the closure");
+                self.app.insert_entity(reservation, build_entity)
+            }
+        }
     }
 
     fn update_entity<T: 'static, R>(

From 2e70059cd980e42dadcb0677e56031931b4940cc Mon Sep 17 00:00:00 2001
From: Richard Feldman <richard@zed.dev>
Date: Tue, 19 May 2026 20:28:09 -0400
Subject: [PATCH 048/105] Remove Skills feature flag (#57162)

Removes the `skills` feature flag now that Skills are ready to ship to
all users. Cleans up all `cx.has_flag::<SkillsFeatureFlag>()` gates
across the agent, agent_ui, prompt_store, and title_bar crates, drops
the now-unused `feature_flags` dependency from `prompt_store` and
`title_bar`, and removes the dead `update_flags(true, vec!["skills"])`
calls from the agent's skills tests.

Closes AI-269

Release Notes:

- Enabled Skills for all users.

---------

Co-authored-by: MartinYe1234 <52641447+MartinYe1234@users.noreply.github.com>
Co-authored-by: Martin Ye <martinye022@gmail.com>
---
 Cargo.lock                                    |  2 -
 crates/agent/src/agent.rs                     | 63 +++++--------------
 crates/agent_ui/src/agent_panel.rs            | 12 +---
 crates/agent_ui/src/agent_ui.rs               | 50 ++++++---------
 crates/feature_flags/src/flags.rs             | 12 ----
 crates/prompt_store/Cargo.toml                |  2 +-
 .../src/rules_to_skills_migration.rs          | 21 ++-----
 crates/title_bar/Cargo.toml                   |  2 +-
 crates/title_bar/src/title_bar.rs             |  2 -
 9 files changed, 43 insertions(+), 123 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index bc935d54f76..31a6af6fcf9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -13688,7 +13688,6 @@ dependencies = [
  "chrono",
  "collections",
  "db",
- "feature_flags",
  "fs",
  "futures 0.3.32",
  "fuzzy",
@@ -18251,7 +18250,6 @@ dependencies = [
  "client",
  "cloud_api_types",
  "db",
- "feature_flags",
  "fs",
  "git_ui",
  "gpui",
diff --git a/crates/agent/src/agent.rs b/crates/agent/src/agent.rs
index 09a13b38818..f704e997ac0 100644
--- a/crates/agent/src/agent.rs
+++ b/crates/agent/src/agent.rs
@@ -38,7 +38,7 @@ use agent_skills::{
 use anyhow::{Context as _, Result, anyhow};
 use chrono::{DateTime, Utc};
 use collections::{HashMap, HashSet, IndexMap};
-use feature_flags::{FeatureFlagAppExt as _, SkillsFeatureFlag};
+
 use fs::Fs;
 use futures::channel::{mpsc, oneshot};
 use futures::future::Shared;
@@ -392,11 +392,11 @@ impl NativeAgent {
     /// Kicks off a one-time scan of the global skills directory if one
     /// isn't already in progress and a watch isn't already active.
     ///
-    /// Idempotent and cheap: returns immediately if the user lacks the
-    /// skills feature flag, or if a scan or watch is already running.
-    /// The expected callers are user-interaction events from the agent
-    /// panel (input focus, slash autocomplete, conversation submit);
-    /// firing this from any of them is equivalent and safe to repeat.
+    /// Idempotent and cheap: returns immediately if a scan or watch is
+    /// already running. The expected callers are user-interaction events
+    /// from the agent panel (input focus, slash autocomplete, conversation
+    /// submit); firing this from any of them is equivalent and safe to
+    /// repeat.
     ///
     /// The scan itself runs detached on the foreground executor. If
     /// `~/.agents/skills/` exists it transitions state to
@@ -405,9 +405,6 @@ impl NativeAgent {
     /// next trigger retries (covering the case where the user creates
     /// the directory after the first scan).
     pub fn ensure_skills_scan_started(&mut self, cx: &mut Context<Self>) {
-        if !cx.has_flag::<SkillsFeatureFlag>() {
-            return;
-        }
         if !matches!(self.skills_state, SkillsState::Idle) {
             return;
         }
@@ -598,12 +595,10 @@ impl NativeAgent {
             // after the thread is constructed are still visible to the
             // model — without this, the catalog and tool would drift out
             // of sync until the session was reopened.
-            if cx.has_flag::<SkillsFeatureFlag>() {
-                thread.add_tool(SkillTool::new(
-                    skills_resolver_for_project(weak.clone(), project_id),
-                    self.fs.clone(),
-                ));
-            }
+            thread.add_tool(SkillTool::new(
+                skills_resolver_for_project(weak.clone(), project_id),
+                self.fs.clone(),
+            ));
         });
 
         let subscriptions = vec![
@@ -822,12 +817,8 @@ impl NativeAgent {
             })
             .collect::<Vec<_>>();
 
-        // Skills are gated behind the "skills" feature flag. Without it we
-        // skip all on-disk lookups so users see no behavior change.
-        let skills_enabled = cx.has_flag::<SkillsFeatureFlag>();
-
         // Load global skills
-        let global_skills_task = if skills_enabled {
+        let global_skills_task = {
             let global_skills_dir = global_skills_dir();
             let global_skills_fs = fs.clone();
             cx.background_spawn(async move {
@@ -838,8 +829,6 @@ impl NativeAgent {
                 )
                 .await
             })
-        } else {
-            Task::ready(Vec::new())
         };
 
         // Load project-local skills, but only from worktrees the user has
@@ -852,7 +841,7 @@ impl NativeAgent {
         // worktrees pick up their skills without restarting.
         let trusted_worktrees = TrustedWorktrees::try_get_global(cx);
         let worktree_store = project.read(cx).worktree_store();
-        let project_skills_task = if skills_enabled {
+        let project_skills_task = {
             let project_skills_futures: Vec<
                 futures::future::BoxFuture<'static, Vec<Result<Skill, SkillLoadError>>>,
             > = worktrees
@@ -897,8 +886,6 @@ impl NativeAgent {
                 })
                 .collect();
             cx.background_spawn(async move { future::join_all(project_skills_futures).await })
-        } else {
-            Task::ready(Vec::new())
         };
         let default_user_rules_task = if let Some(prompt_store) = prompt_store.as_ref() {
             prompt_store.read_with(cx, |prompt_store, cx| {
@@ -1107,7 +1094,7 @@ impl NativeAgent {
         &mut self,
         project: Entity<Project>,
         event: &project::Event,
-        cx: &mut Context<Self>,
+        _cx: &mut Context<Self>,
     ) {
         let project_id = project.entity_id();
         let Some(state) = self.projects.get_mut(&project_id) else {
@@ -1118,16 +1105,14 @@ impl NativeAgent {
                 state.project_context_needs_refresh.send(()).ok();
             }
             project::Event::WorktreeUpdatedEntries(_, items) => {
-                let skills_enabled = cx.has_flag::<SkillsFeatureFlag>();
                 if items.iter().any(|(path, _, _)| {
                     let path_ref = path.as_ref();
                     RULES_FILE_REL_PATHS
                         .iter()
                         .any(|rules_path| path_ref == rules_path.as_ref())
-                        || (skills_enabled
-                            && SKILLS_PREFIX
-                                .as_ref()
-                                .is_some_and(|prefix| path_ref.starts_with(prefix)))
+                        || SKILLS_PREFIX
+                            .as_ref()
+                            .is_some_and(|prefix| path_ref.starts_with(prefix))
                 }) {
                     state.project_context_needs_refresh.send(()).ok();
                 }
@@ -3583,9 +3568,6 @@ mod internal_tests {
     #[gpui::test]
     async fn test_global_skills_load_and_reload(cx: &mut TestAppContext) {
         init_test(cx);
-        cx.update(|cx| {
-            cx.update_flags(true, vec!["skills".to_string()]);
-        });
         let fs = FakeFs::new(cx.executor());
         let skills_dir = global_skills_dir();
         let initial_skill_dir = skills_dir.join("my-skill");
@@ -3651,9 +3633,6 @@ mod internal_tests {
     #[gpui::test]
     async fn test_global_skills_dir_created_after_startup(cx: &mut TestAppContext) {
         init_test(cx);
-        cx.update(|cx| {
-            cx.update_flags(true, vec!["skills".to_string()]);
-        });
         let fs = FakeFs::new(cx.executor());
         let skills_dir = global_skills_dir();
 
@@ -3735,9 +3714,6 @@ mod internal_tests {
     #[gpui::test]
     async fn test_skills_added_after_session_visible_to_skill_tool(cx: &mut TestAppContext) {
         init_test(cx);
-        cx.update(|cx| {
-            cx.update_flags(true, vec!["skills".to_string()]);
-        });
         let fs = FakeFs::new(cx.executor());
         let skills_dir = global_skills_dir();
 
@@ -3879,9 +3855,6 @@ mod internal_tests {
     #[gpui::test]
     async fn test_subagent_skills_lookup_matches_parent(cx: &mut TestAppContext) {
         init_test(cx);
-        cx.update(|cx| {
-            cx.update_flags(true, vec!["skills".to_string()]);
-        });
         let fs = FakeFs::new(cx.executor());
         let skills_dir = global_skills_dir();
         let skill_dir = skills_dir.join("shared-skill");
@@ -3982,9 +3955,6 @@ mod internal_tests {
     #[gpui::test]
     async fn test_skills_appear_as_available_skills(cx: &mut TestAppContext) {
         init_test(cx);
-        cx.update(|cx| {
-            cx.update_flags(true, vec!["skills".to_string()]);
-        });
         let fs = FakeFs::new(cx.executor());
         let skills_dir = global_skills_dir();
 
@@ -4087,7 +4057,6 @@ mod internal_tests {
 
         init_test(cx);
         cx.update(|cx| {
-            cx.update_flags(true, vec!["skills".to_string()]);
             // The trust global isn't created by `init_test`. We need it
             // for `Project::test_with_worktree_trust` to actually wire up
             // trust tracking and for our subscription in
diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs
index 862b007f52c..2e91decb170 100644
--- a/crates/agent_ui/src/agent_panel.rs
+++ b/crates/agent_ui/src/agent_panel.rs
@@ -61,7 +61,7 @@ use collections::HashMap;
 use editor::{Editor, MultiBuffer};
 use extension::ExtensionEvents;
 use extension_host::ExtensionStore;
-use feature_flags::{FeatureFlagAppExt as _, SkillsFeatureFlag};
+
 use fs::Fs;
 use gpui::{
     Action, Anchor, Animation, AnimationExt, AnyElement, App, AsyncWindowContext, ClipboardItem,
@@ -4714,12 +4714,6 @@ impl AgentPanel {
             .with_handle(self.agent_panel_menu_handle.clone())
             .menu({
                 move |window, cx| {
-                    // When the Skills feature flag is on, hide the legacy Rules menu entry.
-                    // The flag is read from a global store populated asynchronously, and
-                    // this menu builder runs on every open, so the latest resolved value is
-                    // reflected when the user clicks the ellipsis.
-                    let skills_enabled = cx.has_flag::<SkillsFeatureFlag>();
-
                     Some(ContextMenu::build(window, cx, |mut menu, _window, _| {
                         menu = menu.context(focus_handle.clone());
 
@@ -4756,10 +4750,6 @@ impl AgentPanel {
                                 .action("Add Custom Server…", Box::new(AddContextServer))
                                 .separator();
 
-                            if !skills_enabled {
-                                menu = menu.action("Rules", Box::new(OpenRulesLibrary::default()));
-                            }
-
                             menu = menu.action("Profiles", Box::new(ManageProfiles::default()));
                         }
 
diff --git a/crates/agent_ui/src/agent_ui.rs b/crates/agent_ui/src/agent_ui.rs
index f67a1d11aaf..c6ef0af0159 100644
--- a/crates/agent_ui/src/agent_ui.rs
+++ b/crates/agent_ui/src/agent_ui.rs
@@ -43,7 +43,7 @@ use ::ui::IconName;
 use agent_client_protocol::schema as acp;
 use agent_settings::{AgentProfileId, AgentSettings};
 use command_palette_hooks::CommandPaletteFilter;
-use feature_flags::{FeatureFlagAppExt as _, SkillsFeatureFlag};
+use feature_flags::FeatureFlagAppExt as _;
 use fs::Fs;
 use gpui::{
     Action, App, Context, Entity, ImageSource, Resource, SharedString, SharedUri, Window, actions,
@@ -560,21 +560,7 @@ pub fn init(
              _: &zed_actions::agent::OpenRulesToSkillsMigrationInfo,
              window: &mut Window,
              cx: &mut Context<Workspace>| {
-                // The banner is the only intended entry point and is
-                // gated on the skills flag, but dispatch from the
-                // command palette or a keybind is still possible — only
-                // open the explainer if the flag is enabled so it never
-                // surfaces outside its intended audience.
-                //
-                // Race note: `has_flag` returns false before server
-                // flags are received, so a dispatch during that brief
-                // window is a no-op even for users who genuinely have
-                // the flag. The banner itself has the same race — it
-                // stays hidden until flags arrive — so a user who can
-                // see the banner has, by definition, already passed it.
-                if cx.has_flag::<SkillsFeatureFlag>() {
-                    crate::ui::RulesToSkillsModal::toggle(workspace, window, cx);
-                }
+                crate::ui::RulesToSkillsModal::toggle(workspace, window, cx);
             },
         );
     })
@@ -608,10 +594,16 @@ pub fn init(
     })
     .detach();
 
-    // Once the `skills` feature flag has resolved, kick off the one-time
-    // migration of non-Default Rules to global Skills. Idempotent and
-    // self-gated on the flag, so it's safe to call on every flag-ready
-    // notification (and a no-op for users without the flag).
+    // Kick off the one-time migration of non-Default Rules to global
+    // Skills, deferred until server feature flags arrive.
+    //
+    // The migration itself is idempotent and no longer gated on a flag,
+    // but the deferral via `on_flags_ready` still matters: the migration
+    // writes to the on-disk `GlobalKeyValueStore`, which dispatches work
+    // on the `sqlezWorker` background thread. In `gpui::test` contexts,
+    // server flags are never received, so this callback never fires —
+    // which keeps that sqlite worker activity from racing with the
+    // `TestScheduler` and tripping its non-determinism panic.
     {
         let fs = fs.clone();
         cx.on_flags_ready(move |_, cx| {
@@ -653,12 +645,6 @@ fn update_command_palette_filter(cx: &mut App) {
         .edit_predictions
         .provider;
 
-    // The Skills feature flag is loaded asynchronously, so this value may
-    // be `false` before flags resolve. `update_command_palette_filter`
-    // gets re-run from `cx.on_flags_ready` (see `init`), which means the
-    // filter is reapplied with the correct value once flags arrive.
-    let skills_enabled = cx.has_flag::<SkillsFeatureFlag>();
-
     CommandPaletteFilter::update_global(cx, |filter, _| {
         use editor::actions::{
             AcceptEditPrediction, AcceptNextLineEditPrediction, AcceptNextWordEditPrediction,
@@ -726,12 +712,12 @@ fn update_command_palette_filter(cx: &mut App) {
             filter.show_namespace("multi_workspace");
         }
 
-        // Hide `assistant: open rules library` when Skills are enabled —
-        // Rules are surfaced through the Skills UI in that case. Applied
-        // after the disable-ai / agent-enabled branches so it overrides
-        // the `show_namespace("assistant")` call above without affecting
-        // the rest of that namespace's actions.
-        if !disable_ai && skills_enabled {
+        // Hide `assistant: open rules library` — Rules are surfaced
+        // through the Skills UI now. Applied after the disable-ai /
+        // agent-enabled branches so it overrides the
+        // `show_namespace("assistant")` call above without affecting the
+        // rest of that namespace's actions.
+        if !disable_ai {
             filter.hide_action_types(&open_rules_library_action);
         } else {
             filter.show_action_types(open_rules_library_action.iter());
diff --git a/crates/feature_flags/src/flags.rs b/crates/feature_flags/src/flags.rs
index bfae995f9f2..9f3c54394b9 100644
--- a/crates/feature_flags/src/flags.rs
+++ b/crates/feature_flags/src/flags.rs
@@ -123,15 +123,3 @@ impl FeatureFlag for AutoWatchFeatureFlag {
     type Value = PresenceFlag;
 }
 register_feature_flag!(AutoWatchFeatureFlag);
-
-pub struct SkillsFeatureFlag;
-
-impl FeatureFlag for SkillsFeatureFlag {
-    const NAME: &'static str = "skills";
-    type Value = PresenceFlag;
-
-    fn enabled_for_staff() -> bool {
-        true
-    }
-}
-register_feature_flag!(SkillsFeatureFlag);
diff --git a/crates/prompt_store/Cargo.toml b/crates/prompt_store/Cargo.toml
index 91bcdd251bf..8c1f296f171 100644
--- a/crates/prompt_store/Cargo.toml
+++ b/crates/prompt_store/Cargo.toml
@@ -18,7 +18,7 @@ assets.workspace = true
 chrono.workspace = true
 collections.workspace = true
 db.workspace = true
-feature_flags.workspace = true
+
 fs.workspace = true
 futures.workspace = true
 fuzzy.workspace = true
diff --git a/crates/prompt_store/src/rules_to_skills_migration.rs b/crates/prompt_store/src/rules_to_skills_migration.rs
index 13dba07207d..7fad0ab389b 100644
--- a/crates/prompt_store/src/rules_to_skills_migration.rs
+++ b/crates/prompt_store/src/rules_to_skills_migration.rs
@@ -24,14 +24,10 @@
 //!   (still using Zed's shipped default content) are skipped so we don't
 //!   pollute AGENTS.md with text the user never wrote.
 //!
-//! Both migrations are gated by:
-//!
-//! * the `skills` feature flag — users without it never have their Rules
-//!   touched in any way;
-//! * a single global "migration already ran" flag persisted in
-//!   [`GlobalKeyValueStore`] — keyed by [`MIGRATION_DONE_KEY`], so a
-//!   shared home directory only gets populated once per machine even
-//!   across release channels.
+//! Both migrations are gated by a single global "migration already ran"
+//! flag persisted in [`GlobalKeyValueStore`] — keyed by
+//! [`MIGRATION_DONE_KEY`], so a shared home directory only gets
+//! populated once per machine even across release channels.
 //!
 //! The migration is intentionally non-destructive: rule rows in the LMDB
 //! database are left in place after the migration. That way users can
@@ -45,7 +41,6 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use agent_skills::{SKILL_FILE_NAME, global_skills_dir, slugify_skill_name};
 use anyhow::{Context as _, Result};
 use db::kvp::GlobalKeyValueStore;
-use feature_flags::{FeatureFlagAppExt as _, SkillsFeatureFlag};
 use fs::Fs;
 use gpui::{App, AsyncApp, Entity, TaskExt as _};
 use serde::{Deserialize, Serialize};
@@ -151,13 +146,9 @@ static MIGRATION_TASK_SPAWNED: AtomicBool = AtomicBool::new(false);
 /// Migrate non-Default user rules to global Skills, if not already done.
 ///
 /// Safe to call on every startup — short-circuits immediately when the
-/// migration has already run, when another invocation in this process
-/// has already started it, or when the user doesn't have the `skills`
-/// feature flag enabled.
+/// migration has already run or when another invocation in this process
+/// has already started it.
 pub fn migrate_rules_to_skills_if_needed(fs: Arc<dyn Fs>, cx: &mut App) {
-    if !cx.has_flag::<SkillsFeatureFlag>() {
-        return;
-    }
     if migration_done() {
         return;
     }
diff --git a/crates/title_bar/Cargo.toml b/crates/title_bar/Cargo.toml
index 61ffd3f8175..4a762b18eef 100644
--- a/crates/title_bar/Cargo.toml
+++ b/crates/title_bar/Cargo.toml
@@ -40,7 +40,7 @@ chrono.workspace = true
 client.workspace = true
 cloud_api_types.workspace = true
 db.workspace = true
-feature_flags.workspace = true
+
 git_ui.workspace = true
 gpui = { workspace = true, features = ["screen-capture"] }
 icons.workspace = true
diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs
index 3bc12a20748..cb2a6406994 100644
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -25,7 +25,6 @@ use auto_update::AutoUpdateStatus;
 use call::ActiveCall;
 use client::{Client, UserStore, zed_urls};
 use cloud_api_types::Plan;
-use feature_flags::{FeatureFlagAppExt as _, SkillsFeatureFlag};
 
 use gpui::{
     Action, Anchor, Animation, AnimationExt, AnyElement, App, Context, Element, Entity, Focusable,
@@ -469,7 +468,6 @@ impl TitleBar {
                 zed_actions::agent::OpenRulesToSkillsMigrationInfo.boxed_clone(),
                 cx,
             )
-            .visible_when(|cx| cx.has_flag::<SkillsFeatureFlag>())
         }));
 
         let mut this = Self {

From 1ddf7407e9987fbab4d5bdf5b8740dc6bd8374c2 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Tue, 19 May 2026 22:26:06 -0300
Subject: [PATCH 049/105] Use the announcement toast for skills support
 (#56873)

Closes AI-244

This PR changes the approach for announcing skills support. It uses the
announcement toast, the same thing used for parallel agents, which
observes a specific version number to be displayed. I ended up
simplifying things a bit by thinking we could rely on documentation for
more detailed information (with more extensive paths and whatnot).

Release Notes:

- N/A

---------

Co-authored-by: Richard Feldman <richard@zed.dev>
Co-authored-by: MartinYe1234 <52641447+MartinYe1234@users.noreply.github.com>
Co-authored-by: Martin Ye <martinye022@gmail.com>
---
 Cargo.lock                                    |   6 +-
 crates/agent_ui/Cargo.toml                    |   2 +-
 crates/agent_ui/src/agent_ui.rs               |  12 -
 .../src/conversation_view/thread_view.rs      |   2 -
 crates/agent_ui/src/ui.rs                     |   2 -
 .../agent_ui/src/ui/rules_to_skills_modal.rs  | 196 -------------
 crates/auto_update_ui/Cargo.toml              |   6 +-
 crates/auto_update_ui/src/auto_update_ui.rs   | 134 +++------
 crates/client/src/zed_urls.rs                 |   9 +-
 .../src/rules_to_skills_migration.rs          |  17 +-
 crates/title_bar/src/title_bar.rs             |  16 +-
 crates/ui/src/components/ai.rs                |   4 +-
 .../ai/parallel_agents_illustration.rs        | 272 ------------------
 .../src/components/ai/skills_illustration.rs  |  86 ++++++
 crates/zed_actions/src/lib.rs                 |   4 -
 15 files changed, 150 insertions(+), 618 deletions(-)
 delete mode 100644 crates/agent_ui/src/ui/rules_to_skills_modal.rs
 delete mode 100644 crates/ui/src/components/ai/parallel_agents_illustration.rs
 create mode 100644 crates/ui/src/components/ai/skills_illustration.rs

diff --git a/Cargo.lock b/Cargo.lock
index 31a6af6fcf9..742b2879176 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1293,22 +1293,20 @@ dependencies = [
 name = "auto_update_ui"
 version = "0.1.0"
 dependencies = [
- "agent_settings",
+ "agent_skills",
  "anyhow",
  "auto_update",
  "client",
  "db",
  "editor",
- "fs",
  "gpui",
  "markdown_preview",
  "notifications",
- "project",
+ "prompt_store",
  "release_channel",
  "semver",
  "serde",
  "serde_json",
- "settings",
  "smol",
  "telemetry",
  "ui",
diff --git a/crates/agent_ui/Cargo.toml b/crates/agent_ui/Cargo.toml
index 03cb331334f..91b20aca27a 100644
--- a/crates/agent_ui/Cargo.toml
+++ b/crates/agent_ui/Cargo.toml
@@ -30,10 +30,10 @@ acp_thread.workspace = true
 action_log.workspace = true
 agent-client-protocol.workspace = true
 agent.workspace = true
-agent_skills.workspace = true
 async-channel.workspace = true
 agent_servers.workspace = true
 agent_settings.workspace = true
+agent_skills.workspace = true
 ai_onboarding.workspace = true
 anyhow.workspace = true
 heapless.workspace = true
diff --git a/crates/agent_ui/src/agent_ui.rs b/crates/agent_ui/src/agent_ui.rs
index c6ef0af0159..ef7ff079b56 100644
--- a/crates/agent_ui/src/agent_ui.rs
+++ b/crates/agent_ui/src/agent_ui.rs
@@ -554,18 +554,6 @@ pub fn init(
         );
     })
     .detach();
-    cx.observe_new(|workspace: &mut Workspace, _window, _cx| {
-        workspace.register_action(
-            |workspace: &mut Workspace,
-             _: &zed_actions::agent::OpenRulesToSkillsMigrationInfo,
-             window: &mut Window,
-             cx: &mut Context<Workspace>| {
-                crate::ui::RulesToSkillsModal::toggle(workspace, window, cx);
-            },
-        );
-    })
-    .detach();
-
     cx.observe_new(ManageProfilesModal::register).detach();
     cx.observe_new(|workspace: &mut Workspace, _window, _cx| {
         workspace.register_action(
diff --git a/crates/agent_ui/src/conversation_view/thread_view.rs b/crates/agent_ui/src/conversation_view/thread_view.rs
index bb8d65fa868..343c21bbec8 100644
--- a/crates/agent_ui/src/conversation_view/thread_view.rs
+++ b/crates/agent_ui/src/conversation_view/thread_view.rs
@@ -333,8 +333,6 @@ pub struct ThreadView {
     pub show_codex_windows_warning: bool,
     pub multi_root_callout_dismissed: bool,
     pub generating_indicator_in_list: bool,
-    /// Errors emitted by the agent while loading SKILL.md files. Each one
-    /// renders as a clickable banner that opens the offending file.
     pub skill_loading_errors: Vec<SkillLoadingError>,
     /// Errors the user has explicitly dismissed. Each entry is matched against
     /// emitted errors by full equality; when an error no longer appears in the
diff --git a/crates/agent_ui/src/ui.rs b/crates/agent_ui/src/ui.rs
index d0625a4f461..d69cfe86a63 100644
--- a/crates/agent_ui/src/ui.rs
+++ b/crates/agent_ui/src/ui.rs
@@ -3,7 +3,6 @@ mod end_trial_upsell;
 mod hold_for_default;
 mod mention_crease;
 mod model_selector_components;
-mod rules_to_skills_modal;
 mod undo_reject_toast;
 
 pub use agent_notification::*;
@@ -11,7 +10,6 @@ pub use end_trial_upsell::*;
 pub use hold_for_default::*;
 pub use mention_crease::*;
 pub use model_selector_components::*;
-pub use rules_to_skills_modal::*;
 pub use undo_reject_toast::*;
 
 /// Returns the appropriate [`DocumentationSide`] for documentation asides
diff --git a/crates/agent_ui/src/ui/rules_to_skills_modal.rs b/crates/agent_ui/src/ui/rules_to_skills_modal.rs
deleted file mode 100644
index 3f889ef1a06..00000000000
--- a/crates/agent_ui/src/ui/rules_to_skills_modal.rs
+++ /dev/null
@@ -1,196 +0,0 @@
-//! Mini modal shown when the user clicks the title-bar Skills
-//! announcement banner. Renders one of two flavours depending on the
-//! persisted [`MigrationResult`]:
-//!
-//! * **No rules migrated** (new user, or an existing user who never
-//!   touched Rules): a generic "Introducing Skills" intro that explains
-//!   what Skills are and how to invoke them.
-//! * **Rules migrated**: a per-destination summary of exactly which
-//!   Rules ended up where (Skills directory, global AGENTS.md, top of
-//!   AGENTS.md for customized built-ins), capped at three names per
-//!   section with an "…and N more" overflow line.
-
-use agent_skills::GLOBAL_SKILLS_DIR_DISPLAY;
-use gpui::{
-    DismissEvent, EventEmitter, FocusHandle, Focusable, IntoElement, ParentElement, Render, Styled,
-};
-use paths::GLOBAL_AGENTS_FILE_DISPLAY;
-use prompt_store::rules_to_skills_migration::{self, MigrationResult};
-use ui::{
-    AlertModal, Button, ButtonCommon, ButtonStyle, Clickable, KeyBinding, ListBulletItem, h_flex,
-    prelude::*,
-};
-use workspace::{ModalView, Workspace};
-
-/// Maximum number of rule names to list inline in the modal before
-/// collapsing the rest into an "…and N more" line.
-const MAX_LISTED_NAMES: usize = 3;
-
-pub struct RulesToSkillsModal {
-    focus_handle: FocusHandle,
-}
-
-impl RulesToSkillsModal {
-    pub fn toggle(workspace: &mut Workspace, window: &mut Window, cx: &mut Context<Workspace>) {
-        workspace.toggle_modal(window, cx, |_window, cx| Self {
-            focus_handle: cx.focus_handle(),
-        });
-    }
-
-    fn dismiss(&mut self, cx: &mut Context<Self>) {
-        cx.emit(DismissEvent);
-    }
-}
-
-impl Focusable for RulesToSkillsModal {
-    fn focus_handle(&self, _: &App) -> FocusHandle {
-        self.focus_handle.clone()
-    }
-}
-
-impl EventEmitter<DismissEvent> for RulesToSkillsModal {}
-
-impl ModalView for RulesToSkillsModal {}
-
-impl Render for RulesToSkillsModal {
-    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let result = rules_to_skills_migration::migration_result().unwrap_or_default();
-
-        let mut modal = AlertModal::new("rules-to-skills-migration")
-            .width(rems(28.))
-            .key_context("RulesToSkillsModal")
-            .track_focus(&self.focus_handle(cx))
-            .on_action(cx.listener(|this, _: &menu::Confirm, _window, cx| this.dismiss(cx)))
-            .on_action(cx.listener(|this, _: &menu::Cancel, _window, cx| this.dismiss(cx)));
-
-        if result.is_empty() {
-            modal = render_introducing_skills(modal);
-        } else {
-            modal = render_migration_summary(modal, &result);
-        }
-
-        // Both flavours close with the same invocation instructions.
-        modal = modal.child(Label::new(
-            "To include a Skill in a prompt, type /skill-name (or @-mention it).",
-        ));
-
-        modal.footer(
-            h_flex().p_3().items_center().justify_end().child(
-                Button::new("got-it", "Got it")
-                    .style(ButtonStyle::Filled)
-                    .layer(ui::ElevationIndex::ModalSurface)
-                    .key_binding(
-                        KeyBinding::for_action(&menu::Confirm, cx)
-                            .map(|kb| kb.size(rems_from_px(12.))),
-                    )
-                    .on_click(cx.listener(|this, _, _window, cx| {
-                        this.dismiss(cx);
-                        cx.stop_propagation();
-                    })),
-            ),
-        )
-    }
-}
-
-/// Render the modal body for users who had no Rules to migrate — a
-/// generic introduction to the Skills feature.
-fn render_introducing_skills(modal: AlertModal) -> AlertModal {
-    modal.title("Introducing Skills").child(Label::new(format!(
-        "Skills are reusable instructions for the agent, stored as Markdown files \
-         under {GLOBAL_SKILLS_DIR_DISPLAY}/<name>/SKILL.md."
-    )))
-}
-
-/// Render the modal body for users whose Rules were migrated, listing
-/// each destination's contents (capped at [`MAX_LISTED_NAMES`] per
-/// section).
-fn render_migration_summary(mut modal: AlertModal, result: &MigrationResult) -> AlertModal {
-    modal = modal.title("Skills have replaced Rules");
-
-    if !result.skill_names.is_empty() {
-        modal = modal.child(Label::new(format!(
-            "These Rules have been migrated to Skills in {GLOBAL_SKILLS_DIR_DISPLAY}:"
-        )));
-        modal = add_bulleted_names(modal, &result.skill_names);
-    }
-
-    if !result.agents_md_names.is_empty() {
-        modal = modal.child(Label::new(format!(
-            "These Default Rules were added to {GLOBAL_AGENTS_FILE_DISPLAY}:"
-        )));
-        modal = add_bulleted_names(modal, &result.agents_md_names);
-    }
-
-    if !result.customized_builtins.is_empty() {
-        modal = modal.child(Label::new(customized_builtins_sentence(
-            &result.customized_builtins,
-        )));
-    }
-
-    modal
-}
-
-/// Append up to [`MAX_LISTED_NAMES`] bullet items naming individual
-/// rules, plus a final "…and N more" bullet if the list is longer.
-fn add_bulleted_names(mut modal: AlertModal, names: &[String]) -> AlertModal {
-    for name in names.iter().take(MAX_LISTED_NAMES) {
-        modal = modal.child(ListBulletItem::new(name.clone()));
-    }
-    if names.len() > MAX_LISTED_NAMES {
-        let extras = names.len() - MAX_LISTED_NAMES;
-        let label = if extras == 1 {
-            "…and 1 more".to_string()
-        } else {
-            format!("…and {extras} more")
-        };
-        modal = modal.child(ListBulletItem::new(label));
-    }
-    modal
-}
-
-/// Build the sentence describing any customized built-in prompts that
-/// were prepended to AGENTS.md. Singular wording for the common
-/// one-built-in case; comma-joined for the (currently hypothetical)
-/// multi-built-in case.
-fn customized_builtins_sentence(names: &[String]) -> String {
-    debug_assert!(
-        !names.is_empty(),
-        "caller should only invoke this for a non-empty list"
-    );
-    if names.len() == 1 {
-        format!(
-            "Your customization of the {name} built-in prompt has been added to the top of \
-             {GLOBAL_AGENTS_FILE_DISPLAY}.",
-            name = names[0],
-        )
-    } else {
-        format!(
-            "Your customizations of these built-in prompts have been added to the top of \
-             {GLOBAL_AGENTS_FILE_DISPLAY}: {joined}.",
-            joined = names.join(", "),
-        )
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn customized_builtins_sentence_uses_singular_wording_for_one_item() {
-        let sentence = customized_builtins_sentence(&["Commit message".to_string()]);
-        assert!(sentence.contains("Your customization of the Commit message"));
-        assert!(sentence.contains("built-in prompt has been added"));
-        assert!(sentence.contains(GLOBAL_AGENTS_FILE_DISPLAY));
-    }
-
-    #[test]
-    fn customized_builtins_sentence_uses_plural_wording_for_multiple_items() {
-        let sentence = customized_builtins_sentence(&[
-            "Commit message".to_string(),
-            "Future Built-in".to_string(),
-        ]);
-        assert!(sentence.contains("customizations of these built-in prompts"));
-        assert!(sentence.contains("Commit message, Future Built-in"));
-    }
-}
diff --git a/crates/auto_update_ui/Cargo.toml b/crates/auto_update_ui/Cargo.toml
index 57daa55394e..7dbec922fc5 100644
--- a/crates/auto_update_ui/Cargo.toml
+++ b/crates/auto_update_ui/Cargo.toml
@@ -12,22 +12,20 @@ workspace = true
 path = "src/auto_update_ui.rs"
 
 [dependencies]
-agent_settings.workspace = true
+agent_skills.workspace = true
 anyhow.workspace = true
 auto_update.workspace = true
 client.workspace = true
 db.workspace = true
 editor.workspace = true
-fs.workspace = true
 gpui.workspace = true
 markdown_preview.workspace = true
 notifications.workspace = true
-project.workspace = true
+prompt_store.workspace = true
 release_channel.workspace = true
 semver.workspace = true
 serde.workspace = true
 serde_json.workspace = true
-settings.workspace = true
 smol.workspace = true
 telemetry.workspace = true
 ui.workspace = true
diff --git a/crates/auto_update_ui/src/auto_update_ui.rs b/crates/auto_update_ui/src/auto_update_ui.rs
index 6bd577ddb1b..080f75ed9be 100644
--- a/crates/auto_update_ui/src/auto_update_ui.rs
+++ b/crates/auto_update_ui/src/auto_update_ui.rs
@@ -1,31 +1,30 @@
 use std::sync::Arc;
 
-use agent_settings::{AgentSettings, WindowLayout};
+use agent_skills::GLOBAL_SKILLS_DIR_DISPLAY;
 use auto_update::{AutoUpdater, release_notes_url};
+use client::zed_urls;
 use db::kvp::Dismissable;
 use editor::{Editor, MultiBuffer};
-use fs::Fs;
 use gpui::{
     App, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, TaskExt, Window, actions,
     prelude::*,
 };
 use markdown_preview::markdown_preview_view::{MarkdownPreviewMode, MarkdownPreviewView};
-use notifications::status_toast::StatusToast;
+use prompt_store::rules_to_skills_migration;
 use release_channel::{AppVersion, ReleaseChannel};
 use semver::Version;
 use serde::Deserialize;
-use settings::Settings as _;
 use smol::io::AsyncReadExt;
-use ui::{AnnouncementToast, ListBulletItem, ParallelAgentsIllustration, prelude::*};
+use ui::{AnnouncementToast, ListBulletItem, SkillsIllustration, prelude::*};
 use util::{ResultExt as _, maybe};
 use workspace::{
-    FocusWorkspaceSidebar, Workspace,
+    Workspace,
     notifications::{
         ErrorMessagePrompt, Notification, NotificationId, SuppressEvent, show_app_notification,
         simple_message_notification::MessageNotification,
     },
 };
-use zed_actions::{ShowUpdateNotification, assistant::FocusAgent};
+use zed_actions::ShowUpdateNotification;
 
 actions!(
     auto_update,
@@ -186,103 +185,57 @@ struct AnnouncementContent {
     description: SharedString,
     bullet_items: Vec<SharedString>,
     primary_action_label: SharedString,
+    secondary_action_label: SharedString,
     primary_action_url: Option<SharedString>,
     primary_action_callback: Option<Arc<dyn Fn(&mut Window, &mut App) + Send + Sync>>,
     secondary_action_url: Option<SharedString>,
     on_dismiss: Option<Arc<dyn Fn(&mut App) + Send + Sync>>,
 }
 
-struct ParallelAgentAnnouncement;
+struct SkillsAnnouncement;
 
-impl Dismissable for ParallelAgentAnnouncement {
-    const KEY: &'static str = "parallel-agent-announcement";
+impl Dismissable for SkillsAnnouncement {
+    const KEY: &'static str = "skills_announcement_dismissed";
 }
 
 fn announcement_for_version(version: &Version, cx: &App) -> Option<AnnouncementContent> {
-    let version_with_parallel_agents = match ReleaseChannel::global(cx) {
-        ReleaseChannel::Stable => Version::new(0, 233, 0),
+    let version_with_skills = match ReleaseChannel::global(cx) {
+        ReleaseChannel::Stable => Version::new(1, 4, 0),
         ReleaseChannel::Dev | ReleaseChannel::Nightly | ReleaseChannel::Preview => {
-            Version::new(0, 232, 0)
+            Version::new(1, 4, 0)
         }
     };
 
-    if *version >= version_with_parallel_agents
-        && !ParallelAgentAnnouncement::dismissed(cx)
-        && !project::DisableAiSettings::get_global(cx).disable_ai
-    {
-        let fs = <dyn Fs>::global(cx);
+    if *version >= version_with_skills && !SkillsAnnouncement::dismissed(cx) {
+        // Only mention the Rules → Skills migration if the user actually
+        // had Rules that got migrated. New users (and existing users who
+        // never created a Rule) would otherwise be confused by a bullet
+        // referring to "your rules" that don't exist.
+        let migrated_anything =
+            rules_to_skills_migration::migration_result().is_some_and(|result| !result.is_empty());
+
+        let mut bullet_items: Vec<SharedString> = Vec::with_capacity(3);
+        bullet_items
+            .push(format!("Skills live in {GLOBAL_SKILLS_DIR_DISPLAY}/<name>/SKILL.md").into());
+        if migrated_anything {
+            bullet_items.push(
+                "Default Rules are converted into your global AGENTS.md; all other rules become skills".into(),
+            );
+        }
+        bullet_items.push("Type / to manually invoke a skill".into());
+
         Some(AnnouncementContent {
-            heading: "Introducing Parallel Agents".into(),
-            description: "Run multiple threads of your favorite agents simultaneously across projects in a new workspace layout, tailored for agentic workflows.".into(),
-            bullet_items: vec![
-                "Use your favorite agents in parallel".into(),
-                "Optionally isolate agents using worktrees".into(),
-                "Combine multiple projects in one window".into(),
-            ],
-            primary_action_label: "Try Agentic Layout".into(),
+            heading: "Introducing Skills Support".into(),
+            description: "Extend the agent with focused instructions and domain knowledge.".into(),
+            bullet_items,
+            primary_action_label: "Try Now".into(),
+            secondary_action_label: "Read Documentation".into(),
             primary_action_url: None,
             primary_action_callback: Some(Arc::new(move |window, cx| {
-                let get_layout = AgentSettings::get_layout(cx);
-                let already_agent_layout = matches!(get_layout, WindowLayout::Agent(_));
-
-                let update;
-                if !already_agent_layout {
-                    update = Some(AgentSettings::set_layout(
-                        WindowLayout::Agent(None),
-                        fs.clone(),
-                        cx,
-                    ));
-                } else {
-                    update = None;
-                }
-
-                let revert_fs = fs.clone();
-                window
-                    .spawn(cx, async move |cx| {
-                        if let Some(update) = update {
-                            update.await.ok();
-                        }
-
-                        cx.update(|window, cx| {
-                            if !already_agent_layout {
-                                if let Some(workspace) = Workspace::for_window(window, cx) {
-                                    let toast = StatusToast::new(
-                                        "You are in the new agentic layout!",
-                                        cx,
-                                        move |this, _cx| {
-                                            this.icon(
-                                                Icon::new(IconName::Check)
-                                                    .size(IconSize::Small)
-                                                    .color(Color::Success),
-                                            )
-                                            .action("Revert", move |_window, cx| {
-                                                let _ = AgentSettings::set_layout(
-                                                    get_layout.clone(),
-                                                    revert_fs.clone(),
-                                                    cx,
-                                                );
-                                            })
-                                            .auto_dismiss(false)
-                                            .dismiss_button(true)
-                                        },
-                                    );
-
-                                    workspace.update(cx, |workspace, cx| {
-                                        workspace.toggle_status_toast(toast, cx);
-                                    });
-                                }
-                            }
-
-                            window.dispatch_action(Box::new(FocusWorkspaceSidebar), cx);
-                            window.dispatch_action(Box::new(FocusAgent), cx);
-                        })
-                    })
-                    .detach();
+                window.dispatch_action(Box::new(zed_actions::assistant::FocusAgent), cx);
             })),
-            on_dismiss: Some(Arc::new(|cx| {
-                ParallelAgentAnnouncement::set_dismissed(true, cx)
-            })),
-            secondary_action_url: Some("https://zed.dev/blog/".into()),
+            on_dismiss: Some(Arc::new(|cx| SkillsAnnouncement::set_dismissed(true, cx))),
+            secondary_action_url: Some(zed_urls::skills_docs(cx).into()),
         })
     } else {
         None
@@ -323,7 +276,7 @@ impl Notification for AnnouncementToastNotification {}
 impl Render for AnnouncementToastNotification {
     fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         AnnouncementToast::new()
-            .illustration(ParallelAgentsIllustration::new())
+            .illustration(SkillsIllustration::new())
             .heading(self.content.heading.clone())
             .description(self.content.description.clone())
             .bullet_items(
@@ -333,11 +286,12 @@ impl Render for AnnouncementToastNotification {
                     .map(|item| ListBulletItem::new(item.clone())),
             )
             .primary_action_label(self.content.primary_action_label.clone())
+            .secondary_action_label(self.content.secondary_action_label.clone())
             .primary_on_click(cx.listener({
                 let url = self.content.primary_action_url.clone();
                 let callback = self.content.primary_action_callback.clone();
                 move |this, _, window, cx| {
-                    telemetry::event!("Parallel Agent Announcement Main Click");
+                    telemetry::event!("Skills Announcement Main Click");
                     if let Some(callback) = &callback {
                         callback(window, cx);
                     }
@@ -350,14 +304,14 @@ impl Render for AnnouncementToastNotification {
             .secondary_on_click(cx.listener({
                 let url = self.content.secondary_action_url.clone();
                 move |_, _, _window, cx| {
-                    telemetry::event!("Parallel Agent Announcement Secondary Click");
+                    telemetry::event!("Skills Announcement Secondary Click");
                     if let Some(url) = &url {
                         cx.open_url(url);
                     }
                 }
             }))
             .dismiss_on_click(cx.listener(|this, _, _window, cx| {
-                telemetry::event!("Parallel Agent Announcement Dismiss");
+                telemetry::event!("Skills Announcement Dismiss");
                 this.dismiss(cx);
             }))
     }
diff --git a/crates/client/src/zed_urls.rs b/crates/client/src/zed_urls.rs
index 662c53cbca4..70ff9537d7a 100644
--- a/crates/client/src/zed_urls.rs
+++ b/crates/client/src/zed_urls.rs
@@ -52,6 +52,10 @@ pub fn edit_prediction_docs(cx: &App) -> String {
     )
 }
 
+pub fn skills_docs(cx: &App) -> String {
+    format!("{server_url}/docs/ai/skills", server_url = server_url(cx))
+}
+
 /// Returns the URL to Zed's ACP registry blog post.
 pub fn acp_registry_blog(cx: &App) -> String {
     format!(
@@ -60,11 +64,6 @@ pub fn acp_registry_blog(cx: &App) -> String {
     )
 }
 
-/// Returns the URL to Zed's Parallel Agents blog post.
-pub fn parallel_agents_blog(cx: &App) -> String {
-    format!("{server_url}/blog", server_url = server_url(cx))
-}
-
 pub fn shared_agent_thread_url(session_id: &str) -> String {
     format!("zed://agent/shared/{}", session_id)
 }
diff --git a/crates/prompt_store/src/rules_to_skills_migration.rs b/crates/prompt_store/src/rules_to_skills_migration.rs
index 7fad0ab389b..89bc0541033 100644
--- a/crates/prompt_store/src/rules_to_skills_migration.rs
+++ b/crates/prompt_store/src/rules_to_skills_migration.rs
@@ -57,15 +57,15 @@ pub const MIGRATION_DONE_KEY: &str = "rules_to_skills_migration_done";
 
 /// Global KVP key for the JSON-serialized [`MigrationResult`] produced by
 /// the most recent migration run — the lists of source-Rule titles that
-/// were migrated to each destination. The title-bar banner and its
-/// explainer modal read this to decide what (if anything) to tell the
-/// user about what changed.
+/// were migrated to each destination. The skills announcement toast
+/// reads this to decide whether to mention the migration in its copy.
 pub const MIGRATION_RESULT_KEY: &str = "rules_to_skills_migration_result";
 
 /// A persistent record of what the rules-to-skills migration actually
 /// migrated. Persisted in [`GlobalKeyValueStore`] under
-/// [`MIGRATION_RESULT_KEY`] and read back by the announcement UI so the
-/// modal can list specific rule names instead of vaguely gesturing.
+/// [`MIGRATION_RESULT_KEY`] and read back by the skills announcement
+/// toast so it can tailor its copy to users who actually had Rules to
+/// migrate.
 ///
 /// All three lists hold the *original* user-facing Rule titles, not the
 /// derived skill slug or any other transformed identifier — those are
@@ -87,10 +87,9 @@ pub struct MigrationResult {
 
 impl MigrationResult {
     /// `true` if the migration didn't actually move any Rule anywhere —
-    /// i.e. the user had no Rules of any kind to migrate. The
-    /// announcement banner/modal uses this to switch between the
-    /// "Introducing: Skills" generic intro and the "Skills have replaced
-    /// Rules" migration summary.
+    /// i.e. the user had no Rules of any kind to migrate. The skills
+    /// announcement toast uses this to omit the migration-flavored
+    /// bullet for users who never had any Rules.
     pub fn is_empty(&self) -> bool {
         self.skill_names.is_empty()
             && self.agents_md_names.is_empty()
diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs
index cb2a6406994..62d11beec30 100644
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -454,21 +454,7 @@ impl TitleBar {
             titlebar
         });
 
-        // The banner label stays static ("Introducing: Skills") regardless
-        // of whether the user had Rules to migrate; the explainer modal
-        // is where the migration-specific summary surfaces. Keeping the
-        // label static avoids the rebuild-on-migration-completion plumbing
-        // we'd otherwise need to dodge the title-bar-vs-migration race.
-        let banner = Some(cx.new(|cx| {
-            OnboardingBanner::new(
-                "Skills Migration Announcement",
-                IconName::Sparkle,
-                "Skills",
-                Some("Introducing:".into()),
-                zed_actions::agent::OpenRulesToSkillsMigrationInfo.boxed_clone(),
-                cx,
-            )
-        }));
+        let banner = None;
 
         let mut this = Self {
             platform_titlebar,
diff --git a/crates/ui/src/components/ai.rs b/crates/ui/src/components/ai.rs
index 91b5385c45b..479ae55ceb5 100644
--- a/crates/ui/src/components/ai.rs
+++ b/crates/ui/src/components/ai.rs
@@ -1,11 +1,11 @@
 mod agent_setup_button;
 mod ai_setting_item;
 mod configured_api_card;
-mod parallel_agents_illustration;
+mod skills_illustration;
 mod thread_item;
 
 pub use agent_setup_button::*;
 pub use ai_setting_item::*;
 pub use configured_api_card::*;
-pub use parallel_agents_illustration::*;
+pub use skills_illustration::*;
 pub use thread_item::*;
diff --git a/crates/ui/src/components/ai/parallel_agents_illustration.rs b/crates/ui/src/components/ai/parallel_agents_illustration.rs
deleted file mode 100644
index e7694e9359f..00000000000
--- a/crates/ui/src/components/ai/parallel_agents_illustration.rs
+++ /dev/null
@@ -1,272 +0,0 @@
-use crate::{DiffStat, Divider, prelude::*};
-use gpui::{Animation, AnimationExt, pulsating_between};
-use std::time::Duration;
-
-#[derive(IntoElement)]
-pub struct ParallelAgentsIllustration;
-
-impl ParallelAgentsIllustration {
-    pub fn new() -> Self {
-        Self
-    }
-}
-
-impl RenderOnce for ParallelAgentsIllustration {
-    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
-        let icon_container = || h_flex().size_4().flex_shrink_0().justify_center();
-
-        let loading_bar = |id: &'static str, width: DefiniteLength, duration_ms: u64| {
-            div()
-                .h(rems_from_px(5.))
-                .w(width)
-                .rounded_full()
-                .bg(cx.theme().colors().element_selected)
-                .with_animation(
-                    id,
-                    Animation::new(Duration::from_millis(duration_ms))
-                        .repeat()
-                        .with_easing(pulsating_between(0.1, 0.8)),
-                    |label, delta| label.opacity(delta),
-                )
-        };
-
-        let skeleton_bar = |width: DefiniteLength| {
-            div().h(rems_from_px(5.)).w(width).rounded_full().bg(cx
-                .theme()
-                .colors()
-                .text_muted
-                .opacity(0.05))
-        };
-
-        let time =
-            |time: SharedString| Label::new(time).size(LabelSize::XSmall).color(Color::Muted);
-
-        let worktree = |worktree: SharedString| {
-            h_flex()
-                .gap_0p5()
-                .child(
-                    Icon::new(IconName::GitWorktree)
-                        .color(Color::Muted)
-                        .size(IconSize::Indicator),
-                )
-                .child(
-                    Label::new(worktree)
-                        .size(LabelSize::XSmall)
-                        .color(Color::Muted),
-                )
-        };
-
-        let dot_separator = || {
-            Label::new("•")
-                .size(LabelSize::Small)
-                .color(Color::Muted)
-                .alpha(0.5)
-        };
-
-        let agent = |title: SharedString, icon: IconName, selected: bool, data: Vec<AnyElement>| {
-            v_flex()
-                .when(selected, |this| {
-                    this.bg(cx.theme().colors().element_active.opacity(0.2))
-                })
-                .p_1()
-                .child(
-                    h_flex()
-                        .w_full()
-                        .gap_1()
-                        .child(
-                            icon_container()
-                                .child(Icon::new(icon).size(IconSize::XSmall).color(Color::Muted)),
-                        )
-                        .map(|this| {
-                            if selected {
-                                this.child(
-                                    Label::new(title)
-                                        .color(Color::Muted)
-                                        .size(LabelSize::XSmall),
-                                )
-                            } else {
-                                this.child(skeleton_bar(relative(0.7)))
-                            }
-                        }),
-                )
-                .child(
-                    h_flex()
-                        .opacity(0.8)
-                        .w_full()
-                        .gap_1()
-                        .child(icon_container())
-                        .children(data),
-                )
-        };
-
-        let agents = v_flex()
-            .col_span(3)
-            .bg(cx.theme().colors().elevated_surface_background)
-            .child(agent(
-                "Fix branch label".into(),
-                IconName::ZedAgent,
-                true,
-                vec![
-                    worktree("bug-fix".into()).into_any_element(),
-                    dot_separator().into_any_element(),
-                    DiffStat::new("ds", 5, 2)
-                        .label_size(LabelSize::XSmall)
-                        .into_any_element(),
-                    dot_separator().into_any_element(),
-                    time("2m".into()).into_any_element(),
-                ],
-            ))
-            .child(Divider::horizontal())
-            .child(agent(
-                "Improve thread id".into(),
-                IconName::AiClaude,
-                false,
-                vec![
-                    DiffStat::new("ds", 120, 84)
-                        .label_size(LabelSize::XSmall)
-                        .into_any_element(),
-                    dot_separator().into_any_element(),
-                    time("16m".into()).into_any_element(),
-                ],
-            ))
-            .child(Divider::horizontal())
-            .child(agent(
-                "Refactor archive view".into(),
-                IconName::AiOpenAi,
-                false,
-                vec![
-                    worktree("silent-forest".into()).into_any_element(),
-                    dot_separator().into_any_element(),
-                    time("37m".into()).into_any_element(),
-                ],
-            ));
-
-        let thread_view = v_flex()
-            .col_span(3)
-            .h_full()
-            .flex_1()
-            .border_l_1()
-            .border_color(cx.theme().colors().border.opacity(0.5))
-            .bg(cx.theme().colors().panel_background)
-            .child(
-                h_flex()
-                    .px_1p5()
-                    .py_0p5()
-                    .w_full()
-                    .justify_between()
-                    .border_b_1()
-                    .border_color(cx.theme().colors().border.opacity(0.5))
-                    .child(
-                        Label::new("Fix branch label")
-                            .size(LabelSize::XSmall)
-                            .color(Color::Muted),
-                    )
-                    .child(
-                        Icon::new(IconName::Plus)
-                            .size(IconSize::Indicator)
-                            .color(Color::Muted),
-                    ),
-            )
-            .child(
-                div().p_1().child(
-                    v_flex()
-                        .px_1()
-                        .py_1p5()
-                        .gap_1()
-                        .border_1()
-                        .border_color(cx.theme().colors().border.opacity(0.5))
-                        .bg(cx.theme().colors().editor_background)
-                        .rounded_sm()
-                        .shadow_sm()
-                        .child(skeleton_bar(relative(0.7)))
-                        .child(skeleton_bar(relative(0.2))),
-                ),
-            )
-            .child(
-                v_flex()
-                    .p_2()
-                    .gap_1()
-                    .child(loading_bar("a", relative(0.55), 2200))
-                    .child(loading_bar("b", relative(0.75), 2000))
-                    .child(loading_bar("c", relative(0.25), 2400)),
-            );
-
-        let file_row = |indent: usize, is_folder: bool, bar_width: Rems| {
-            let indent_px = rems_from_px((indent as f32) * 4.0);
-
-            h_flex()
-                .px_2()
-                .py_px()
-                .gap_1()
-                .pl(indent_px)
-                .child(
-                    icon_container().child(
-                        Icon::new(if is_folder {
-                            IconName::FolderOpen
-                        } else {
-                            IconName::FileRust
-                        })
-                        .size(IconSize::Indicator)
-                        .color(Color::Custom(cx.theme().colors().icon_muted.opacity(0.2))),
-                    ),
-                )
-                .child(
-                    div().h_1p5().w(bar_width).rounded_sm().bg(cx
-                        .theme()
-                        .colors()
-                        .text
-                        .opacity(if is_folder { 0.15 } else { 0.1 })),
-                )
-        };
-
-        let project_panel = v_flex()
-            .col_span(1)
-            .h_full()
-            .flex_1()
-            .border_l_1()
-            .border_color(cx.theme().colors().border.opacity(0.5))
-            .bg(cx.theme().colors().panel_background)
-            .child(
-                v_flex()
-                    .child(file_row(0, true, rems_from_px(42.0)))
-                    .child(file_row(1, true, rems_from_px(28.0)))
-                    .child(file_row(2, false, rems_from_px(52.0)))
-                    .child(file_row(2, false, rems_from_px(36.0)))
-                    .child(file_row(2, false, rems_from_px(44.0)))
-                    .child(file_row(1, true, rems_from_px(34.0)))
-                    .child(file_row(2, false, rems_from_px(48.0)))
-                    .child(file_row(2, true, rems_from_px(26.0)))
-                    .child(file_row(3, false, rems_from_px(40.0)))
-                    .child(file_row(3, false, rems_from_px(56.0)))
-                    .child(file_row(1, false, rems_from_px(38.0)))
-                    .child(file_row(0, true, rems_from_px(30.0)))
-                    .child(file_row(1, false, rems_from_px(46.0)))
-                    .child(file_row(1, false, rems_from_px(32.0))),
-            );
-
-        let workspace = div()
-            .absolute()
-            .top_8()
-            .grid()
-            .grid_cols(7)
-            .w(rems_from_px(380.))
-            .rounded_t_sm()
-            .border_1()
-            .border_color(cx.theme().colors().border.opacity(0.5))
-            .shadow_md()
-            .child(agents)
-            .child(thread_view)
-            .child(project_panel);
-
-        h_flex()
-            .relative()
-            .h(rems_from_px(180.))
-            .bg(cx.theme().colors().editor_background.opacity(0.6))
-            .justify_center()
-            .items_end()
-            .rounded_t_md()
-            .overflow_hidden()
-            .bg(gpui::black().opacity(0.2))
-            .child(workspace)
-    }
-}
diff --git a/crates/ui/src/components/ai/skills_illustration.rs b/crates/ui/src/components/ai/skills_illustration.rs
new file mode 100644
index 00000000000..8f2de0078d6
--- /dev/null
+++ b/crates/ui/src/components/ai/skills_illustration.rs
@@ -0,0 +1,86 @@
+use crate::prelude::*;
+use gpui::{linear_color_stop, linear_gradient};
+
+#[derive(IntoElement)]
+pub struct SkillsIllustration;
+
+impl SkillsIllustration {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl RenderOnce for SkillsIllustration {
+    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
+        let skill_crease = |label: SharedString, source: SharedString| {
+            h_flex()
+                .py_1()
+                .px_1p5()
+                .gap_1p5()
+                .border_1()
+                .border_color(cx.theme().colors().border)
+                .bg(cx.theme().colors().element_active.opacity(0.5))
+                .justify_center()
+                .rounded_md()
+                .shadow_sm()
+                .child(
+                    Icon::new(IconName::Sparkle)
+                        .color(Color::Muted)
+                        .size(IconSize::XSmall),
+                )
+                .child(Label::new(label).size(LabelSize::XSmall).buffer_font(cx))
+                .child(
+                    Label::new(format!("({source})"))
+                        .size(LabelSize::XSmall)
+                        .color(Color::Muted)
+                        .buffer_font(cx),
+                )
+        };
+
+        let skill_list = v_flex()
+            .absolute()
+            .top_8()
+            .gap_2p5()
+            .items_center()
+            .child(
+                h_flex()
+                    .gap_2p5()
+                    .child(skill_crease("img-gen".into(), "studio".into()))
+                    .child(skill_crease("frontend-design".into(), "global".into())),
+            )
+            .child(
+                h_flex()
+                    .gap_2p5()
+                    .child(skill_crease("brainstorming".into(), "global".into()))
+                    .child(skill_crease("borrow-checker-expert".into(), "zed".into())),
+            )
+            .child(
+                h_flex()
+                    .gap_2p5()
+                    .child(skill_crease("grill-with-docs".into(), "global".into()))
+                    .child(skill_crease("video-edit".into(), "studio".into())),
+            );
+
+        let gradient_bg = cx.theme().colors().editor_background;
+        let gradient_fade = div()
+            .absolute()
+            .rounded_t_md()
+            .inset_0()
+            .bg(linear_gradient(
+                0.,
+                linear_color_stop(gradient_bg.opacity(0.8), 0.),
+                linear_color_stop(gradient_bg.opacity(0.0), 1.),
+            ));
+
+        v_flex()
+            .relative()
+            .h(rems_from_px(150.))
+            .justify_end()
+            .items_center()
+            .rounded_t_md()
+            .overflow_hidden()
+            .bg(gpui::black().opacity(0.2))
+            .child(skill_list)
+            .child(gradient_fade)
+    }
+}
diff --git a/crates/zed_actions/src/lib.rs b/crates/zed_actions/src/lib.rs
index bcfaad5e8ab..da51f3ccc75 100644
--- a/crates/zed_actions/src/lib.rs
+++ b/crates/zed_actions/src/lib.rs
@@ -514,10 +514,6 @@ pub mod agent {
             ResetAgentZoom,
             /// Pastes clipboard content without any formatting.
             PasteRaw,
-            /// Opens the "Skills have replaced Rules" explainer modal,
-            /// describing the one-time migration of non-Default Rules to
-            /// global Skills. Dispatched from the title-bar banner.
-            OpenRulesToSkillsMigrationInfo,
         ]
     );
 

From 7c1005934041b65eef5c1e1d44294c12ea157685 Mon Sep 17 00:00:00 2001
From: Agus Zubiaga <agus@zed.dev>
Date: Tue, 19 May 2026 23:22:25 -0300
Subject: [PATCH 050/105] ui: Add thousands separators to diff stats (#56754)

<img width="282" height="90" alt="CleanShot 2026-05-14 at 11 28 40@2x"
src="https://github.com/user-attachments/assets/34516022-0e26-4380-9e80-568256483309"></img>

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [ ] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Release Notes:

- Improved diff stats by formatting large line counts with thousand
separators.
---
 Cargo.lock                            |  1 +
 crates/ui/Cargo.toml                  |  1 +
 crates/ui/src/components/diff_stat.rs | 10 +++++++---
 3 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 742b2879176..7d1d803623e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -19173,6 +19173,7 @@ dependencies = [
  "icons",
  "itertools 0.14.0",
  "menu",
+ "num-format",
  "schemars 1.0.4",
  "serde",
  "smallvec",
diff --git a/crates/ui/Cargo.toml b/crates/ui/Cargo.toml
index 4ae0e6d2e46..97469cae36c 100644
--- a/crates/ui/Cargo.toml
+++ b/crates/ui/Cargo.toml
@@ -21,6 +21,7 @@ gpui_macros.workspace = true
 icons.workspace = true
 itertools.workspace = true
 menu.workspace = true
+num-format.workspace = true
 schemars.workspace = true
 serde.workspace = true
 smallvec.workspace = true
diff --git a/crates/ui/src/components/diff_stat.rs b/crates/ui/src/components/diff_stat.rs
index c2e76b171e7..5fd88903470 100644
--- a/crates/ui/src/components/diff_stat.rs
+++ b/crates/ui/src/components/diff_stat.rs
@@ -1,5 +1,6 @@
 use crate::Tooltip;
 use crate::prelude::*;
+use num_format::{Locale, ToFormattedString};
 
 #[derive(IntoElement, RegisterComponent)]
 pub struct DiffStat {
@@ -35,16 +36,19 @@ impl DiffStat {
 impl RenderOnce for DiffStat {
     fn render(self, _: &mut Window, _cx: &mut App) -> impl IntoElement {
         let tooltip = self.tooltip;
+        let added = self.added.to_formatted_string(&Locale::en);
+        let removed = self.removed.to_formatted_string(&Locale::en);
+
         h_flex()
             .id(self.id)
             .gap_1()
             .child(
-                Label::new(format!("+\u{2009}{}", self.added))
+                Label::new(format!("+\u{2009}{added}"))
                     .color(Color::Success)
                     .size(self.label_size),
             )
             .child(
-                Label::new(format!("\u{2012}\u{2009}{}", self.removed))
+                Label::new(format!("\u{2012}\u{2009}{removed}"))
                     .color(Color::Error)
                     .size(self.label_size),
             )
@@ -73,7 +77,7 @@ impl Component for DiffStat {
         let diff_stat_example = vec![single_example(
             "Default",
             container()
-                .child(DiffStat::new("id", 1, 2))
+                .child(DiffStat::new("id", 1_234, 5_678))
                 .into_any_element(),
         )];
 

From 661f185f9ffc6ebb4462d08f62522983196723a4 Mon Sep 17 00:00:00 2001
From: David <git@davidstephenson.net>
Date: Tue, 19 May 2026 22:33:07 -0400
Subject: [PATCH 051/105] Add file icon for Ballerina (.bal) files (#56799)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Summary

- Adds a `ballerina` icon key to the default icon theme, mapping the
`.bal` file suffix to a new SVG under
`assets/icons/file_icons/ballerina.svg`.
- Icon is the monochrome Ballerina mark from the official WSO2 VS Code
extension, rescaled to Zed's 16×16 viewBox.

## Icon source / license

The SVG is adapted from `ballerina-inverse.svg` in
[wso2/vscode-extensions](https://github.com/wso2/vscode-extensions),
which is Apache-2.0 licensed. The original 400×400 geometry is preserved
via the existing `translate`/`scale` transform; only the viewBox and
fill were normalized to match the convention used by the other icons in
`assets/icons/file_icons/`.

## Test plan

- [x] `cargo build --release --bin zed`
- [x] Opened a folder containing `.bal` files and confirmed the icon
renders in the project panel and tabs.
- [x] Alphabetical ordering preserved in both
`FILE_SUFFIXES_BY_ICON_KEY` and `FILE_ICONS`.

Release Notes:

- N/A

---------

Co-authored-by: Danilo Leal <daniloleal09@gmail.com>
Co-authored-by: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
---
 assets/icons/file_icons/ballerina.svg | 8 ++++++++
 crates/theme/src/icon_theme.rs        | 2 ++
 2 files changed, 10 insertions(+)
 create mode 100644 assets/icons/file_icons/ballerina.svg

diff --git a/assets/icons/file_icons/ballerina.svg b/assets/icons/file_icons/ballerina.svg
new file mode 100644
index 00000000000..4a8287252c6
--- /dev/null
+++ b/assets/icons/file_icons/ballerina.svg
@@ -0,0 +1,8 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M4.57391 3.54203V5.2877L5.96882 5.81793C6.73561 6.10752 7.38411 6.35224 7.41674 6.36039C7.46161 6.37263 7.46977 5.96476 7.46977 4.08858V1.80044H6.02184H4.57391V3.54203Z" fill="#C6CAD0" stroke="#C6CAD0" stroke-width="0.483833"/>
+<path d="M8.53021 4.08451C8.53021 5.34074 8.54245 6.36856 8.56284 6.36856C8.57916 6.36856 9.22359 6.12384 9.99853 5.8261L11.4057 5.28771L11.4179 3.54205L11.4261 1.80046H9.97814H8.53021V4.08451Z" fill="#C6CAD0" stroke="#C6CAD0" stroke-width="0.483833"/>
+<path d="M4.57391 7.1435C4.57391 7.54728 4.58615 7.87766 4.60654 7.87766C4.66772 7.87766 6.49089 7.16797 6.49089 7.1435C6.49089 7.11902 4.66772 6.40934 4.60654 6.40934C4.58615 6.40934 4.57391 6.73971 4.57391 7.1435Z" fill="#C6CAD0" stroke="#C6CAD0" stroke-width="0.483833"/>
+<path d="M10.4186 6.76826C9.91696 6.95996 9.50909 7.12718 9.50909 7.1435C9.50909 7.16797 11.3323 7.87766 11.3975 7.87766C11.4138 7.87766 11.4261 7.54728 11.4261 7.1435C11.4261 6.58064 11.4138 6.40934 11.3771 6.41341C11.3486 6.41749 10.9162 6.57656 10.4186 6.76826Z" fill="#C6CAD0" stroke="#C6CAD0" stroke-width="0.483833"/>
+<path d="M5.9729 8.46498L4.57391 8.99929V11.5974V14.1996H5.32439C6.00553 14.1996 6.07894 14.1914 6.09933 14.1262C6.11157 14.0895 6.42563 13.0616 6.79679 11.8421L7.46977 9.63148V8.77496C7.46977 8.11422 7.45753 7.91844 7.42082 7.92252C7.39227 7.9266 6.73969 8.16724 5.9729 8.46498Z" fill="#C6CAD0" stroke="#C6CAD0" stroke-width="0.483833"/>
+<path d="M8.53021 8.77904V9.63964L9.1828 11.785C9.5458 12.9678 9.85986 13.9957 9.88025 14.065L9.92512 14.1996H10.6756H11.4261L11.4179 11.5974L11.4057 8.99929L9.99853 8.45682C9.22359 8.16316 8.57916 7.91844 8.56284 7.91844C8.54245 7.91844 8.53021 8.30591 8.53021 8.77904Z" fill="#C6CAD0" stroke="#C6CAD0" stroke-width="0.483833"/>
+</svg>
diff --git a/crates/theme/src/icon_theme.rs b/crates/theme/src/icon_theme.rs
index a1d65dddc46..5303f2952e8 100644
--- a/crates/theme/src/icon_theme.rs
+++ b/crates/theme/src/icon_theme.rs
@@ -80,6 +80,7 @@ const FILE_SUFFIXES_BY_ICON_KEY: &[(&str, &[&str])] = &[
         ],
     ),
     ("backup", &["bak"]),
+    ("ballerina", &["bal"]),
     ("bicep", &["bicep"]),
     ("bun", &["lockb"]),
     ("c", &["c", "h"]),
@@ -312,6 +313,7 @@ const FILE_SUFFIXES_BY_ICON_KEY: &[(&str, &[&str])] = &[
 const FILE_ICONS: &[(&str, &str)] = &[
     ("astro", "icons/file_icons/astro.svg"),
     ("audio", "icons/file_icons/audio.svg"),
+    ("ballerina", "icons/file_icons/ballerina.svg"),
     ("bicep", "icons/file_icons/file.svg"),
     ("bun", "icons/file_icons/bun.svg"),
     ("c", "icons/file_icons/c.svg"),

From e2c38b535829d351345fbac695bada34be61ee4f Mon Sep 17 00:00:00 2001
From: MartinYe1234 <52641447+MartinYe1234@users.noreply.github.com>
Date: Tue, 19 May 2026 19:40:57 -0700
Subject: [PATCH 052/105] Replace Rules UI with Skills creation UI (#56924)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replaces the legacy Rules creation UI with a focused "New Skill"
creation window when the `SkillsFeatureFlag` is on.

The new `skills_library` crate provides a single-skill form with:
- Name, Description, and Body fields (placeholders double as labels)
- Live validation matching the SKILL.md spec (name: 1–64 lowercase +
digits + hyphens, no leading/trailing hyphen; description: non-empty,
≤1024 chars)
- A scope dropdown listing every local worktree in the originating
workspace plus "Global"
- An Optional Parameters card with the `disable-model-invocation`
checkbox
- Save writes `<scope>/.agents/skills/<name>/SKILL.md` via
`serde_yaml_ng` (YAML-safe escaping), refuses to overwrite existing
skills, shows a success toast in the originating workspace, then closes
the window

The "Rules" entry in the agent panel triple-dot menu is renamed to
"Skills" when the flag is on. The existing `cmd-alt-l` keyboard shortcut
still works: `AgentPanel::deploy_rules_library` reroutes to
`deploy_skills_library` when the flag is on, so any persisted keymaps
and the menu's automatic shortcut lookup keep functioning without
changes to the default keymap files.

The old `rules_library` crate is intentionally left in place for this PR
— once the flag rolls out and the few remaining `OpenRulesLibrary {
prompt_to_select }` call sites (in thread_view link handlers and
@-mention crease) are migrated to an "open existing skill" flow, a
follow-up can delete the crate entirely.

15 unit tests cover the validation rules, frontmatter formatting
(including YAML-special-character round-tripping), and disk write
behavior (creates directory, refuses overwrite).

Closes AI-247

Release Notes:

- Added a new Skills creation UI that replaces the old Rules library
when the Skills feature flag is enabled.

---------

Co-authored-by: Danilo Leal <daniloleal09@gmail.com>
---
 Cargo.lock                                   |   25 +
 Cargo.toml                                   |    2 +
 assets/keymaps/default-linux.json            |   16 +
 assets/keymaps/default-macos.json            |   18 +
 assets/keymaps/default-windows.json          |   18 +
 assets/keymaps/vim.json                      |   20 +-
 crates/agent_skills/agent_skills.rs          |  167 ++-
 crates/agent_ui/Cargo.toml                   |    1 +
 crates/agent_ui/src/agent_panel.rs           |  188 +--
 crates/agent_ui/src/agent_ui.rs              |    4 +
 crates/settings_ui/src/pages/skills_setup.rs |    6 +-
 crates/skill_creator/Cargo.toml              |   36 +
 crates/skill_creator/LICENSE-GPL             |    1 +
 crates/skill_creator/src/skill_creator.rs    | 1073 ++++++++++++++++++
 crates/zed/src/zed.rs                        |    1 +
 crates/zed_actions/src/lib.rs                |    2 +
 16 files changed, 1466 insertions(+), 112 deletions(-)
 create mode 100644 crates/skill_creator/Cargo.toml
 create mode 120000 crates/skill_creator/LICENSE-GPL
 create mode 100644 crates/skill_creator/src/skill_creator.rs

diff --git a/Cargo.lock b/Cargo.lock
index 7d1d803623e..877ae7160ff 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -438,6 +438,7 @@ dependencies = [
  "serde_json",
  "serde_json_lenient",
  "settings",
+ "skill_creator",
  "streaming_diff",
  "task",
  "telemetry",
@@ -16532,6 +16533,30 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
 
+[[package]]
+name = "skill_creator"
+version = "0.1.0"
+dependencies = [
+ "agent_skills",
+ "anyhow",
+ "editor",
+ "fs",
+ "gpui",
+ "language",
+ "menu",
+ "platform_title_bar",
+ "release_channel",
+ "serde_json",
+ "serde_yaml_ng",
+ "settings",
+ "theme_settings",
+ "ui",
+ "ui_input",
+ "util",
+ "workspace",
+ "worktree",
+]
+
 [[package]]
 name = "skrifa"
 version = "0.37.0"
diff --git a/Cargo.toml b/Cargo.toml
index 7e113da2f7e..619cc83a084 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -172,6 +172,7 @@ members = [
     "crates/rope",
     "crates/rpc",
     "crates/rules_library",
+    "crates/skill_creator",
     "crates/scheduler",
     "crates/schema_generator",
     "crates/search",
@@ -432,6 +433,7 @@ rodio = { git = "https://github.com/RustAudio/rodio", rev = "e50e726ddd0292f6ef9
 rope = { path = "crates/rope" }
 rpc = { path = "crates/rpc" }
 rules_library = { path = "crates/rules_library" }
+skill_creator = { path = "crates/skill_creator" }
 scheduler = { path = "crates/scheduler" }
 search = { path = "crates/search" }
 session = { path = "crates/session" }
diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json
index 0988611644f..349c980e8bb 100644
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -1558,4 +1558,20 @@
       "shift-tab": "git_graph::FocusPreviousTabStop",
     },
   },
+  {
+    "context": "SkillCreator",
+    "bindings": {
+      "ctrl-w": "workspace::CloseWindow",
+      "tab": "skill_creator::FocusNextField",
+      "shift-tab": "skill_creator::FocusPreviousField",
+    },
+  },
+  {
+    "context": "SkillCreator > Editor",
+    "bindings": {
+      "ctrl-w": "workspace::CloseWindow",
+      "tab": "skill_creator::FocusNextField",
+      "shift-tab": "skill_creator::FocusPreviousField",
+    },
+  },
 ]
diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json
index 4c9aa4c0bce..23fd201b0d2 100644
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -1651,4 +1651,22 @@
       "shift-tab": "git_graph::FocusPreviousTabStop",
     },
   },
+  {
+    "context": "SkillCreator",
+    "use_key_equivalents": true,
+    "bindings": {
+      "cmd-w": "workspace::CloseWindow",
+      "tab": "skill_creator::FocusNextField",
+      "shift-tab": "skill_creator::FocusPreviousField",
+    },
+  },
+  {
+    "context": "SkillCreator > Editor",
+    "use_key_equivalents": true,
+    "bindings": {
+      "cmd-w": "workspace::CloseWindow",
+      "tab": "skill_creator::FocusNextField",
+      "shift-tab": "skill_creator::FocusPreviousField",
+    },
+  },
 ]
diff --git a/assets/keymaps/default-windows.json b/assets/keymaps/default-windows.json
index ea11c7f423b..3eece808cc6 100644
--- a/assets/keymaps/default-windows.json
+++ b/assets/keymaps/default-windows.json
@@ -1577,4 +1577,22 @@
       "shift-tab": "git_graph::FocusPreviousTabStop",
     },
   },
+  {
+    "context": "SkillCreator",
+    "use_key_equivalents": true,
+    "bindings": {
+      "ctrl-w": "workspace::CloseWindow",
+      "tab": "skill_creator::FocusNextField",
+      "shift-tab": "skill_creator::FocusPreviousField",
+    },
+  },
+  {
+    "context": "SkillCreator > Editor",
+    "use_key_equivalents": true,
+    "bindings": {
+      "ctrl-w": "workspace::CloseWindow",
+      "tab": "skill_creator::FocusNextField",
+      "shift-tab": "skill_creator::FocusPreviousField",
+    },
+  },
 ]
diff --git a/assets/keymaps/vim.json b/assets/keymaps/vim.json
index 396c6e40852..bcb114acfae 100644
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -943,7 +943,7 @@
       "space w j": "workspace::ActivatePaneDown",
       "space w k": "workspace::ActivatePaneUp",
       "space w l": "workspace::ActivatePaneRight",
-	  "space w q": "pane::CloseActiveItem",
+      "space w q": "pane::CloseActiveItem",
     },
   },
   {
@@ -1056,8 +1056,8 @@
       "ctrl-d": "git_graph::ScrollDown",
       "ctrl-u": "git_graph::ScrollUp",
       "shift-g": "menu::SelectLast",
-      "g g": "menu::SelectFirst"
-    }
+      "g g": "menu::SelectFirst",
+    },
   },
   {
     "context": "GitPanel && ChangesList && !GitBranchSelector",
@@ -1205,4 +1205,18 @@
       "enter": "editor::Newline",
     },
   },
+  {
+    "context": "SkillCreator",
+    "bindings": {
+      "tab": "skill_creator::FocusNextField",
+      "shift-tab": "skill_creator::FocusPreviousField",
+    },
+  },
+  {
+    "context": "SkillCreator > Editor",
+    "bindings": {
+      "tab": "skill_creator::FocusNextField",
+      "shift-tab": "skill_creator::FocusPreviousField",
+    },
+  },
 ]
diff --git a/crates/agent_skills/agent_skills.rs b/crates/agent_skills/agent_skills.rs
index 2b37d88c649..0c240998f74 100644
--- a/crates/agent_skills/agent_skills.rs
+++ b/crates/agent_skills/agent_skills.rs
@@ -1,5 +1,5 @@
 use anyhow::{Context as _, Result};
-use const_format::concatcp;
+use const_format::{concatcp, formatcp};
 use fs::Fs;
 use futures::StreamExt;
 use gpui::{Global, SharedString};
@@ -251,8 +251,8 @@ pub fn parse_skill_frontmatter(
 
     let (metadata, _body) = extract_frontmatter(content)?;
 
-    validate_name(&metadata.name)?;
-    validate_description(&metadata.description)?;
+    validate_name(&metadata.name).map_err(anyhow::Error::msg)?;
+    validate_description(&metadata.description).map_err(anyhow::Error::msg)?;
 
     let directory_path = skill_file_path
         .parent()
@@ -346,6 +346,14 @@ fn extract_frontmatter(content: &str) -> Result<(SkillMetadata, &str)> {
 /// by [`validate_name`].
 pub const MAX_SKILL_NAME_LEN: usize = 64;
 
+/// Maximum length (in bytes) for a valid skill description. Mirrors the
+/// upper bound enforced by [`validate_description`].
+///
+/// Byte-based rather than char-based because that's what `.len()` returns
+/// and what every caller currently measures; the UI also surfaces this
+/// limit as a byte count so the editor's counter matches the validator.
+pub const MAX_SKILL_DESCRIPTION_LEN: usize = 1024;
+
 /// Convert an arbitrary human-readable string into a valid skill name, or
 /// return `None` if no valid name can be produced (e.g. the input contains
 /// no ASCII alphanumeric characters at all).
@@ -410,34 +418,54 @@ pub fn slugify_skill_name(input: &str) -> Option<String> {
     if slug.is_empty() { None } else { Some(slug) }
 }
 
-fn validate_name(name: &str) -> Result<()> {
+/// Validate a skill name against the rules enforced by both the loader
+/// and the create-skill UI.
+///
+/// Rules:
+/// * non-empty
+/// * at most [`MAX_SKILL_NAME_LEN`] bytes
+/// * ASCII lowercase letters, digits, and hyphens only
+/// * must not start or end with a hyphen — [`slugify_skill_name`]
+///   already guarantees this for its output, so requiring it in the
+///   validator keeps hand-written `SKILL.md` files consistent with
+///   slugifier output
+///
+/// Error messages are returned as `&'static str` (interpolated at
+/// compile time via `formatcp!`) so that UI surfaces can store them in
+/// `Option<&'static str>` fields without allocating, and loader callers
+/// can convert them to `anyhow::Error` via `anyhow::Error::msg`.
+pub fn validate_name(name: &str) -> Result<(), &'static str> {
     if name.is_empty() {
-        anyhow::bail!("Skill name cannot be empty");
+        return Err("Skill name cannot be empty");
     }
-
     if name.len() > MAX_SKILL_NAME_LEN {
-        anyhow::bail!("Skill name must be at most {MAX_SKILL_NAME_LEN} characters");
+        return Err(formatcp!(
+            "Skill name must be at most {MAX_SKILL_NAME_LEN} characters"
+        ));
+    }
+    if name.starts_with('-') || name.ends_with('-') {
+        return Err("Skill name must not start or end with a hyphen");
     }
-
     if !name
         .chars()
         .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-')
     {
-        anyhow::bail!("Skill name must contain only lowercase letters, numbers, and hyphens");
+        return Err("Skill name must contain only lowercase letters, numbers, and hyphens");
     }
-
     Ok(())
 }
 
-fn validate_description(description: &str) -> Result<()> {
-    if description.is_empty() {
-        anyhow::bail!("Skill description cannot be empty");
+/// Validate a skill description against the rules enforced by both the
+/// loader and the create-skill UI.
+pub fn validate_description(description: &str) -> Result<(), &'static str> {
+    if description.trim().is_empty() {
+        return Err("Skill description cannot be empty");
     }
-
-    if description.len() > 1024 {
-        anyhow::bail!("Skill description must be at most 1024 characters");
+    if description.len() > MAX_SKILL_DESCRIPTION_LEN {
+        return Err(formatcp!(
+            "Skill description must be at most {MAX_SKILL_DESCRIPTION_LEN} bytes"
+        ));
     }
-
     Ok(())
 }
 
@@ -672,8 +700,8 @@ pub fn builtin_skills() -> Vec<Skill> {
 /// gets a synthetic `<built-in>` path since it doesn't live on disk.
 fn parse_builtin_skill(name: &str, content: &'static str) -> Result<Skill> {
     let (metadata, body) = extract_frontmatter(content)?;
-    validate_name(&metadata.name)?;
-    validate_description(&metadata.description)?;
+    validate_name(&metadata.name).map_err(anyhow::Error::msg)?;
+    validate_description(&metadata.description).map_err(anyhow::Error::msg)?;
 
     let synthetic_dir = PathBuf::from(format!("<built-in>/{}", name));
     let synthetic_path = synthetic_dir.join(SKILL_FILE_NAME);
@@ -1004,12 +1032,8 @@ Content.
             SkillSource::Global,
         );
         assert!(result.is_err());
-        assert!(
-            result
-                .unwrap_err()
-                .to_string()
-                .contains("at most 64 characters")
-        );
+        let expected = format!("at most {MAX_SKILL_NAME_LEN} characters");
+        assert!(result.unwrap_err().to_string().contains(&expected));
     }
 
     #[test]
@@ -1285,12 +1309,8 @@ Content.
             SkillSource::Global,
         );
         assert!(result.is_err());
-        assert!(
-            result
-                .unwrap_err()
-                .to_string()
-                .contains("at most 1024 characters")
-        );
+        let expected = format!("at most {MAX_SKILL_DESCRIPTION_LEN} bytes");
+        assert!(result.unwrap_err().to_string().contains(&expected));
     }
 
     #[test]
@@ -1891,4 +1911,89 @@ description: A skill with no body content
             "project/.AGENTS/SKILLS/foo"
         )));
     }
+
+    #[test]
+    fn validate_name_accepts_valid_names() {
+        assert!(validate_name("draft-pr").is_ok());
+        assert!(validate_name("a").is_ok());
+        assert!(validate_name("skill1").is_ok());
+        assert!(validate_name(&"a".repeat(MAX_SKILL_NAME_LEN)).is_ok());
+    }
+
+    #[test]
+    fn validate_name_rejects_empty() {
+        assert!(validate_name("").is_err());
+    }
+
+    #[test]
+    fn validate_name_rejects_uppercase() {
+        assert!(validate_name("Draft-PR").is_err());
+    }
+
+    #[test]
+    fn validate_name_rejects_leading_and_trailing_hyphens() {
+        assert!(validate_name("-draft").is_err());
+        assert!(validate_name("draft-").is_err());
+    }
+
+    #[test]
+    fn validate_name_rejects_invalid_chars() {
+        assert!(validate_name("draft_pr").is_err());
+        assert!(validate_name("draft pr").is_err());
+        assert!(validate_name("draft.pr").is_err());
+    }
+
+    #[test]
+    fn validate_name_rejects_too_long() {
+        assert!(validate_name(&"a".repeat(MAX_SKILL_NAME_LEN + 1)).is_err());
+    }
+
+    #[test]
+    fn validate_description_accepts_valid() {
+        assert!(validate_description("A useful skill").is_ok());
+    }
+
+    #[test]
+    fn validate_description_rejects_empty_and_whitespace_only() {
+        assert!(validate_description("").is_err());
+        assert!(validate_description("   ").is_err());
+        assert!(validate_description("\t\n ").is_err());
+    }
+
+    #[test]
+    fn validate_description_rejects_too_long() {
+        assert!(validate_description(&"a".repeat(MAX_SKILL_DESCRIPTION_LEN + 1)).is_err());
+    }
+
+    #[test]
+    fn validate_description_length_is_measured_in_bytes() {
+        // "é" is 2 bytes in UTF-8. A string of MAX/2 + 1 "é" characters has
+        // only ~MAX/2 + 1 chars but exceeds MAX bytes, so it must be
+        // rejected by a byte-based validator (and accepted by a char-based
+        // one). This regression-tests the byte semantics that the loader
+        // and UI both rely on.
+        let chars = MAX_SKILL_DESCRIPTION_LEN / 2 + 1;
+        let description = "é".repeat(chars);
+        assert!(description.chars().count() <= MAX_SKILL_DESCRIPTION_LEN);
+        assert!(description.len() > MAX_SKILL_DESCRIPTION_LEN);
+        assert!(validate_description(&description).is_err());
+    }
+
+    #[test]
+    fn slugify_output_always_passes_validate_name() {
+        for input in [
+            "foo",
+            "Foo Bar",
+            "rock & roll",
+            "---weird---",
+            "a".repeat(200).as_str(),
+        ] {
+            if let Some(slug) = slugify_skill_name(input) {
+                assert!(
+                    validate_name(&slug).is_ok(),
+                    "slug {slug:?} from {input:?} failed validate_name"
+                );
+            }
+        }
+    }
 }
diff --git a/crates/agent_ui/Cargo.toml b/crates/agent_ui/Cargo.toml
index 91b20aca27a..91c0f21a51f 100644
--- a/crates/agent_ui/Cargo.toml
+++ b/crates/agent_ui/Cargo.toml
@@ -89,6 +89,7 @@ remote.workspace = true
 remote_connection.workspace = true
 rope.workspace = true
 rules_library.workspace = true
+skill_creator.workspace = true
 schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs
index 2e91decb170..c7a962b277d 100644
--- a/crates/agent_ui/src/agent_panel.rs
+++ b/crates/agent_ui/src/agent_panel.rs
@@ -27,7 +27,7 @@ use zed_actions::{
         ResetAgentZoom, ResetOnboarding, ResolveConflictedFilesWithAgent,
         ResolveConflictsWithAgent, ReviewBranchDiff,
     },
-    assistant::{FocusAgent, OpenRulesLibrary, Toggle, ToggleFocus},
+    assistant::{FocusAgent, OpenRulesLibrary, OpenSkillCreator, Toggle, ToggleFocus},
 };
 
 use crate::ExpandMessageEditor;
@@ -38,7 +38,7 @@ use crate::terminal_thread_metadata_store::{TerminalThreadMetadata, TerminalThre
 use crate::thread_metadata_store::{ThreadId, ThreadMetadataStore, ThreadMetadataStoreEvent};
 use crate::{
     AddContextServer, AgentDiffPane, ConversationView, CopyThreadToClipboard, Follow,
-    InlineAssistant, LoadThreadFromClipboard, NewThread, OpenActiveThreadAsMarkdown, OpenAgentDiff,
+    LoadThreadFromClipboard, NewThread, OpenActiveThreadAsMarkdown, OpenAgentDiff,
     ResetTrialEndUpsell, ResetTrialUpsell, ShowAllSidebarThreadMetadata, ShowThreadMetadata,
     ToggleNewThreadMenu, ToggleOptionsMenu,
     agent_configuration::{AgentConfiguration, AssistantConfigurationEvent},
@@ -66,16 +66,16 @@ use fs::Fs;
 use gpui::{
     Action, Anchor, Animation, AnimationExt, AnyElement, App, AsyncWindowContext, ClipboardItem,
     Entity, EventEmitter, ExternalPaths, FocusHandle, Focusable, KeyContext, Pixels,
-    PlatformDisplay, Subscription, Task, TaskExt, UpdateGlobal, WeakEntity, WindowHandle,
-    prelude::*, pulsating_between,
+    PlatformDisplay, Subscription, Task, TaskExt, WeakEntity, WindowHandle, prelude::*,
+    pulsating_between,
 };
 use language::LanguageRegistry;
 use language_model::LanguageModelRegistry;
 use project::{Project, ProjectPath, Worktree};
-use prompt_store::{PromptStore, UserPromptId};
-use rules_library::{RulesLibrary, open_rules_library};
+use prompt_store::PromptStore;
 use settings::TerminalDockPosition;
 use settings::{NotifyWhenAgentWaiting, Settings, update_settings_file};
+use skill_creator::open_skill_creator;
 use terminal::{Event as TerminalEvent, terminal_settings::TerminalSettings};
 use terminal_view::{TerminalView, terminal_panel::TerminalPanel};
 use theme_settings::ThemeSettings;
@@ -300,6 +300,14 @@ pub fn init(cx: &mut App) {
                         });
                     }
                 })
+                .register_action(|workspace, action: &OpenSkillCreator, window, cx| {
+                    if let Some(panel) = workspace.panel::<AgentPanel>(cx) {
+                        workspace.focus_panel::<AgentPanel>(window, cx);
+                        panel.update(cx, |panel, cx| {
+                            panel.deploy_skill_creator(action, window, cx)
+                        });
+                    }
+                })
                 .register_action(|workspace, _: &Follow, window, cx| {
                     workspace.follow(CollaboratorId::Agent, window, cx);
                 })
@@ -2980,16 +2988,27 @@ impl AgentPanel {
 
     fn deploy_rules_library(
         &mut self,
-        action: &OpenRulesLibrary,
+        _action: &OpenRulesLibrary,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        // The legacy Rules action is rerouted to the skill creator so the
+        // existing keyboard shortcut (still bound to `OpenRulesLibrary` in
+        // the default keymaps) and any persisted user keymap entries keep
+        // working.
+        self.deploy_skill_creator(&OpenSkillCreator, window, cx);
+    }
+
+    fn deploy_skill_creator(
+        &mut self,
+        _action: &OpenSkillCreator,
         _window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        open_rules_library(
+        open_skill_creator(
+            Some(self.workspace.clone()),
             self.language_registry.clone(),
-            Box::new(PromptLibraryInlineAssist::new(self.workspace.clone())),
-            action
-                .prompt_to_select
-                .map(|uuid| UserPromptId(uuid).into()),
+            self.fs.clone(),
             cx,
         )
         .detach_and_log_err(cx);
@@ -4670,6 +4689,16 @@ impl AgentPanel {
         cx: &mut Context<Self>,
     ) -> impl IntoElement {
         let focus_handle = self.focus_handle(cx);
+        // Resolve menu shortcuts at the thread root; the active editor can
+        // shadow panel-level commands such as OpenRulesLibrary.
+        let menu_action_context = match &self.base_view {
+            BaseView::AgentThread { conversation_view } => conversation_view
+                .read(cx)
+                .active_thread()
+                .map(|thread| thread.read(cx).focus_handle.clone())
+                .unwrap_or_else(|| focus_handle.clone()),
+            _ => focus_handle.clone(),
+        };
         let showing_terminal = matches!(self.visible_surface(), VisibleSurface::Terminal(_));
 
         let conversation_view = match &self.base_view {
@@ -4698,16 +4727,13 @@ impl AgentPanel {
             .trigger_with_tooltip(
                 IconButton::new("agent-options-menu", IconName::Ellipsis)
                     .icon_size(IconSize::Small),
-                {
-                    let focus_handle = focus_handle.clone();
-                    move |_window, cx| {
-                        Tooltip::for_action_in(
-                            "Toggle Agent Menu",
-                            &ToggleOptionsMenu,
-                            &focus_handle,
-                            cx,
-                        )
-                    }
+                move |_window, cx| {
+                    Tooltip::for_action_in(
+                        "Toggle Agent Menu",
+                        &ToggleOptionsMenu,
+                        &focus_handle,
+                        cx,
+                    )
                 },
             )
             .anchor(Anchor::TopRight)
@@ -4715,7 +4741,7 @@ impl AgentPanel {
             .menu({
                 move |window, cx| {
                     Some(ContextMenu::build(window, cx, |mut menu, _window, _| {
-                        menu = menu.context(focus_handle.clone());
+                        menu = menu.context(menu_action_context.clone());
 
                         if can_regenerate_thread_title {
                             menu = menu.header("Current Thread");
@@ -4750,6 +4776,14 @@ impl AgentPanel {
                                 .action("Add Custom Server…", Box::new(AddContextServer))
                                 .separator();
 
+                            menu = menu.entry(
+                                "Skills",
+                                Some(Box::new(OpenRulesLibrary::default())),
+                                |window, cx| {
+                                    window.dispatch_action(Box::new(OpenSkillCreator), cx);
+                                },
+                            );
+
                             menu = menu.action("Profiles", Box::new(ManageProfiles::default()));
                         }
 
@@ -5575,6 +5609,7 @@ impl Render for AgentPanel {
             }))
             .on_action(cx.listener(Self::open_active_thread_as_markdown))
             .on_action(cx.listener(Self::deploy_rules_library))
+            .on_action(cx.listener(Self::deploy_skill_creator))
             .on_action(cx.listener(Self::go_back))
             .on_action(cx.listener(Self::toggle_options_menu))
             .on_action(cx.listener(Self::increase_font_size))
@@ -5626,57 +5661,6 @@ impl Render for AgentPanel {
     }
 }
 
-struct PromptLibraryInlineAssist {
-    workspace: WeakEntity<Workspace>,
-}
-
-impl PromptLibraryInlineAssist {
-    pub fn new(workspace: WeakEntity<Workspace>) -> Self {
-        Self { workspace }
-    }
-}
-
-impl rules_library::InlineAssistDelegate for PromptLibraryInlineAssist {
-    fn assist(
-        &self,
-        prompt_editor: &Entity<Editor>,
-        initial_prompt: Option<String>,
-        window: &mut Window,
-        cx: &mut Context<RulesLibrary>,
-    ) {
-        InlineAssistant::update_global(cx, |assistant, cx| {
-            let Some(workspace) = self.workspace.upgrade() else {
-                return;
-            };
-            let Some(panel) = workspace.read(cx).panel::<AgentPanel>(cx) else {
-                return;
-            };
-            let project = workspace.read(cx).project().downgrade();
-            let panel = panel.read(cx);
-            let thread_store = panel.thread_store().clone();
-            assistant.assist(
-                prompt_editor,
-                self.workspace.clone(),
-                project,
-                thread_store,
-                None,
-                initial_prompt,
-                window,
-                cx,
-            );
-        })
-    }
-
-    fn focus_agent_panel(
-        &self,
-        workspace: &mut Workspace,
-        window: &mut Window,
-        cx: &mut Context<Workspace>,
-    ) -> bool {
-        workspace.focus_panel::<AgentPanel>(window, cx).is_some()
-    }
-}
-
 struct OnboardingUpsell;
 
 impl Dismissable for OnboardingUpsell {
@@ -5958,7 +5942,7 @@ mod tests {
     use anyhow::{Result, anyhow};
     use feature_flags::FeatureFlagAppExt;
     use fs::FakeFs;
-    use gpui::{App, TestAppContext, VisualTestContext};
+    use gpui::{App, TestAppContext, UpdateGlobal, VisualTestContext};
     use parking_lot::Mutex;
     use project::{Project, WorktreePaths};
     use std::any::Any;
@@ -8030,6 +8014,60 @@ mod tests {
         });
     }
 
+    #[gpui::test]
+    async fn test_skills_menu_entry_shows_rules_shortcut(cx: &mut TestAppContext) {
+        init_test(cx);
+        cx.update(|cx| {
+            let default_key_bindings = settings::KeymapFile::load_asset_allow_partial_failure(
+                "keymaps/default-macos.json",
+                cx,
+            )
+            .unwrap();
+            cx.bind_keys(default_key_bindings);
+            agent::ThreadStore::init_global(cx);
+            language_model::LanguageModelRegistry::test(cx);
+        });
+
+        let fs = FakeFs::new(cx.executor());
+        cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));
+        fs.insert_tree("/project", json!({ "file.txt": "" })).await;
+        let project = Project::test(fs.clone(), [Path::new("/project")], cx).await;
+
+        let multi_workspace =
+            cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
+        let workspace = multi_workspace
+            .read_with(cx, |multi_workspace, _cx| {
+                multi_workspace.workspace().clone()
+            })
+            .unwrap();
+        let mut cx = VisualTestContext::from_window(multi_workspace.into(), cx);
+
+        let panel = workspace.update_in(&mut cx, |workspace, window, cx| {
+            let panel = cx.new(|cx| AgentPanel::new(workspace, None, window, cx));
+            workspace.add_panel(panel.clone(), window, cx);
+            panel
+        });
+        open_thread_with_connection(&panel, StubAgentConnection::new(), &mut cx);
+        workspace.update_in(&mut cx, |workspace, window, cx| {
+            workspace.focus_panel::<AgentPanel>(window, cx);
+        });
+        cx.run_until_parked();
+
+        panel.update_in(&mut cx, |panel, window, cx| {
+            panel.toggle_options_menu(&ToggleOptionsMenu, window, cx);
+        });
+        cx.run_until_parked();
+
+        assert!(
+            cx.debug_bounds("MENU_ITEM-Skills").is_some(),
+            "Skills menu item should be visible"
+        );
+        assert!(
+            cx.debug_bounds("KEY_BINDING-l").is_some(),
+            "Skills menu item should show the OpenRulesLibrary shortcut"
+        );
+    }
+
     #[gpui::test]
     async fn test_terminal_close_event_closes_without_sidebar(cx: &mut TestAppContext) {
         let (panel, mut cx) = setup_panel(cx).await;
diff --git a/crates/agent_ui/src/agent_ui.rs b/crates/agent_ui/src/agent_ui.rs
index ef7ff079b56..bb3fb26ac62 100644
--- a/crates/agent_ui/src/agent_ui.rs
+++ b/crates/agent_ui/src/agent_ui.rs
@@ -506,6 +506,7 @@ pub fn init(
 ) {
     agent::ThreadStore::init_global(cx);
     rules_library::init(cx);
+    skill_creator::init(cx);
     if !is_eval {
         // Initializing the language model from the user settings messes with the eval, so we only initialize them when
         // we're not running inside of the eval.
@@ -650,6 +651,7 @@ fn update_command_palette_filter(cx: &mut App) {
         ];
 
         let open_rules_library_action = [TypeId::of::<zed_actions::assistant::OpenRulesLibrary>()];
+        let open_skill_creator_action = [TypeId::of::<zed_actions::assistant::OpenSkillCreator>()];
 
         if disable_ai {
             filter.hide_namespace("agent");
@@ -707,8 +709,10 @@ fn update_command_palette_filter(cx: &mut App) {
         // rest of that namespace's actions.
         if !disable_ai {
             filter.hide_action_types(&open_rules_library_action);
+            filter.show_action_types(open_skill_creator_action.iter());
         } else {
             filter.show_action_types(open_rules_library_action.iter());
+            filter.hide_action_types(&open_skill_creator_action);
         }
     });
 }
diff --git a/crates/settings_ui/src/pages/skills_setup.rs b/crates/settings_ui/src/pages/skills_setup.rs
index e3ea3bb548c..bce8b7e7f51 100644
--- a/crates/settings_ui/src/pages/skills_setup.rs
+++ b/crates/settings_ui/src/pages/skills_setup.rs
@@ -56,7 +56,7 @@ pub(crate) fn render_skills_setup_page(
                         .gap_2()
                         .child(Label::new(message).color(Color::Muted))
                         .child(
-                            Button::new("open-agent-panel", "Create with Agent")
+                            Button::new("open-skill-creator", "Create a Skill")
                                 .tab_index(0_isize)
                                 .style(ButtonStyle::Outlined)
                                 .end_icon(
@@ -71,10 +71,10 @@ pub(crate) fn render_skills_setup_page(
                                     original_window
                                         .update(cx, |_workspace, original_window, cx| {
                                             original_window.dispatch_action(
-                                                zed_actions::assistant::ToggleFocus.boxed_clone(),
+                                                zed_actions::assistant::OpenSkillCreator
+                                                    .boxed_clone(),
                                                 cx,
                                             );
-                                            original_window.activate_window();
                                         })
                                         .log_err();
                                     window.remove_window();
diff --git a/crates/skill_creator/Cargo.toml b/crates/skill_creator/Cargo.toml
new file mode 100644
index 00000000000..2ffd7bb85df
--- /dev/null
+++ b/crates/skill_creator/Cargo.toml
@@ -0,0 +1,36 @@
+[package]
+name = "skill_creator"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/skill_creator.rs"
+
+[dependencies]
+agent_skills.workspace = true
+anyhow.workspace = true
+editor.workspace = true
+fs.workspace = true
+gpui.workspace = true
+language.workspace = true
+menu.workspace = true
+platform_title_bar.workspace = true
+release_channel.workspace = true
+serde_yaml_ng.workspace = true
+settings.workspace = true
+theme_settings.workspace = true
+ui.workspace = true
+ui_input.workspace = true
+util.workspace = true
+workspace.workspace = true
+worktree.workspace = true
+
+[dev-dependencies]
+fs = { workspace = true, features = ["test-support"] }
+gpui = { workspace = true, features = ["test-support"] }
+serde_json.workspace = true
diff --git a/crates/skill_creator/LICENSE-GPL b/crates/skill_creator/LICENSE-GPL
new file mode 120000
index 00000000000..89e542f750c
--- /dev/null
+++ b/crates/skill_creator/LICENSE-GPL
@@ -0,0 +1 @@
+../../LICENSE-GPL
\ No newline at end of file
diff --git a/crates/skill_creator/src/skill_creator.rs b/crates/skill_creator/src/skill_creator.rs
new file mode 100644
index 00000000000..8a1ee24437d
--- /dev/null
+++ b/crates/skill_creator/src/skill_creator.rs
@@ -0,0 +1,1073 @@
+use agent_skills::{
+    AGENTS_DIR_NAME, GLOBAL_SKILLS_DIR_DISPLAY, SKILL_FILE_NAME, SKILLS_DIR_NAME, SkillMetadata,
+    global_skills_dir, validate_description, validate_name,
+};
+use anyhow::{Context as _, Result};
+use editor::{CurrentLineHighlight, Editor, EditorElement, EditorEvent, EditorStyle};
+use fs::Fs;
+use gpui::{
+    App, Bounds, DEFAULT_ADDITIONAL_WINDOW_SIZE, Entity, FocusHandle, Focusable, Subscription,
+    Task, TextStyle, Tiling, TitlebarOptions, WeakEntity, WindowBounds, WindowHandle,
+    WindowOptions, actions, point,
+};
+use language::{Buffer, LanguageRegistry, language_settings::SoftWrap};
+use platform_title_bar::PlatformTitleBar;
+use release_channel::ReleaseChannel;
+use settings::{ActionSequence, Settings};
+use std::path::PathBuf;
+use std::sync::Arc;
+use theme_settings::ThemeSettings;
+use ui::{
+    ContextMenu, Divider, DropdownMenu, DropdownStyle, Headline, HeadlineSize, SwitchField,
+    prelude::*,
+};
+use ui_input::{ErasedEditorEvent, InputField};
+use util::ResultExt;
+use workspace::{
+    Toast, Workspace, WorkspaceSettings, client_side_decorations, notifications::NotificationId,
+};
+use worktree::WorktreeId;
+
+actions!(
+    skill_creator,
+    [SaveSkill, Cancel, FocusNextField, FocusPreviousField,]
+);
+
+const NAME_FIELD_TAB_INDEX: isize = 1;
+const DESCRIPTION_FIELD_TAB_INDEX: isize = 2;
+const SCOPE_FIELD_TAB_INDEX: isize = 3;
+const DISABLE_MODEL_INVOCATION_TAB_INDEX: isize = 4;
+const BODY_FIELD_TAB_INDEX: isize = 5;
+
+pub fn init(_cx: &mut App) {}
+
+#[derive(Clone, Debug)]
+enum ScopeChoice {
+    Global,
+    Project {
+        worktree_id: WorktreeId,
+        root_name: SharedString,
+        abs_path: Arc<std::path::Path>,
+    },
+}
+
+impl ScopeChoice {
+    fn label(&self) -> SharedString {
+        match self {
+            ScopeChoice::Global => "Global".into(),
+            ScopeChoice::Project { root_name, .. } => root_name.clone(),
+        }
+    }
+
+    fn key(&self) -> SharedString {
+        match self {
+            ScopeChoice::Global => "global".into(),
+            ScopeChoice::Project { worktree_id, .. } => {
+                SharedString::from(format!("project-{}", worktree_id.to_usize()))
+            }
+        }
+    }
+
+    /// Absolute path of the `.agents/skills` directory this scope writes to.
+    fn skills_dir(&self) -> PathBuf {
+        match self {
+            ScopeChoice::Global => global_skills_dir(),
+            ScopeChoice::Project { abs_path, .. } => {
+                abs_path.join(AGENTS_DIR_NAME).join(SKILLS_DIR_NAME)
+            }
+        }
+    }
+}
+
+/// Collect the user-visible worktrees from the originating workspace and
+/// turn them into project-scope choices. Returns an empty `Vec` if the
+/// workspace can't be read (e.g. it was already dropped).
+fn project_scopes_from_workspace(
+    workspace: &Option<WeakEntity<Workspace>>,
+    cx: &App,
+) -> Vec<ScopeChoice> {
+    let Some(workspace) = workspace.as_ref().and_then(|w| w.upgrade()) else {
+        return Vec::new();
+    };
+    let workspace = workspace.read(cx);
+    let project = workspace.project().read(cx);
+    project
+        .visible_worktrees(cx)
+        .filter_map(|worktree| {
+            let worktree = worktree.read(cx);
+            if !worktree.is_local() {
+                return None;
+            }
+            Some(ScopeChoice::Project {
+                worktree_id: worktree.id(),
+                root_name: SharedString::from(worktree.root_name_str().to_string()),
+                abs_path: worktree.abs_path(),
+            })
+        })
+        .collect()
+}
+
+/// Open the skills library window. If one is already open, brings it to the
+/// foreground.
+pub fn open_skill_creator(
+    workspace: Option<WeakEntity<Workspace>>,
+    language_registry: Arc<LanguageRegistry>,
+    fs: Arc<dyn Fs>,
+    cx: &mut App,
+) -> Task<Result<WindowHandle<SkillCreator>>> {
+    cx.spawn(async move |cx| {
+        let existing = cx.update(|cx| {
+            let handle = cx
+                .windows()
+                .into_iter()
+                .find_map(|window| window.downcast::<SkillCreator>());
+            if let Some(handle) = handle {
+                handle
+                    .update(cx, |_, window, _| window.activate_window())
+                    .ok();
+                Some(handle)
+            } else {
+                None
+            }
+        });
+        if let Some(window) = existing {
+            return Ok(window);
+        }
+
+        cx.update(|cx| {
+            let app_id = ReleaseChannel::global(cx).app_id();
+            let bounds = Bounds::centered(None, DEFAULT_ADDITIONAL_WINDOW_SIZE, cx);
+            let window_decorations = match std::env::var("ZED_WINDOW_DECORATIONS") {
+                Ok(val) if val == "server" => gpui::WindowDecorations::Server,
+                Ok(val) if val == "client" => gpui::WindowDecorations::Client,
+                _ => match WorkspaceSettings::get_global(cx).window_decorations {
+                    settings::WindowDecorations::Server => gpui::WindowDecorations::Server,
+                    settings::WindowDecorations::Client => gpui::WindowDecorations::Client,
+                },
+            };
+            cx.open_window(
+                WindowOptions {
+                    titlebar: Some(TitlebarOptions {
+                        title: Some("New Skill".into()),
+                        appears_transparent: true,
+                        traffic_light_position: Some(point(px(12.0), px(12.0))),
+                    }),
+                    app_id: Some(app_id.to_owned()),
+                    window_bounds: Some(WindowBounds::Windowed(bounds)),
+                    window_background: cx.theme().window_background_appearance(),
+                    window_decorations: Some(window_decorations),
+                    window_min_size: Some(DEFAULT_ADDITIONAL_WINDOW_SIZE),
+                    kind: gpui::WindowKind::Floating,
+                    ..Default::default()
+                },
+                |window, cx| {
+                    cx.new(|cx| SkillCreator::new(workspace, language_registry, fs, window, cx))
+                },
+            )
+        })
+    })
+}
+
+pub struct SkillCreator {
+    focus_handle: FocusHandle,
+    title_bar: Option<Entity<PlatformTitleBar>>,
+    workspace: Option<WeakEntity<Workspace>>,
+    fs: Arc<dyn Fs>,
+    name_editor: Entity<InputField>,
+    description_editor: Entity<InputField>,
+    body_editor: Entity<Editor>,
+    description_length: usize,
+    scopes: Vec<ScopeChoice>,
+    selected_scope_key: SharedString,
+    disable_model_invocation: bool,
+    name_error: Option<&'static str>,
+    description_error: Option<&'static str>,
+    body_error: Option<&'static str>,
+    save_error: Option<SharedString>,
+    saving: bool,
+    // Held so that dropping the entity (e.g. the window closing) cancels
+    // an in-flight save. Detaching the task instead would let
+    // `write_skill_to_disk` complete after the UI is gone, silently
+    // creating a SKILL.md on disk with no toast and no error feedback.
+    save_task: Option<Task<()>>,
+    _subscriptions: Vec<Subscription>,
+}
+
+impl SkillCreator {
+    fn new(
+        workspace: Option<WeakEntity<Workspace>>,
+        language_registry: Arc<LanguageRegistry>,
+        fs: Arc<dyn Fs>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let focus_handle = cx.focus_handle();
+        let project_scopes = project_scopes_from_workspace(&workspace, cx);
+
+        // Default to first project scope (project-level) when available;
+        // otherwise fall back to Global.
+        let mut scopes: Vec<ScopeChoice> = Vec::with_capacity(project_scopes.len() + 1);
+        scopes.push(ScopeChoice::Global);
+        scopes.extend(project_scopes);
+        let selected_scope_key = scopes
+            .iter()
+            .find(|scope| matches!(scope, ScopeChoice::Project { .. }))
+            .map(|scope| scope.key())
+            .unwrap_or_else(|| ScopeChoice::Global.key());
+
+        let name_editor = cx.new(|cx| {
+            InputField::new(window, cx, "my-new-skill")
+                .label("Name")
+                .tab_index(NAME_FIELD_TAB_INDEX)
+                .tab_stop(true)
+        });
+        // Focus the name field on open. Without this, no element inside
+        // the window has focus, so dispatching the `Cancel` action from
+        // the Cancel button (which walks the focused element's dispatch
+        // path looking for `on_action` handlers) silently does nothing
+        // until the user manually clicks into one of the editors. The
+        // name editor is also the natural first field to type into.
+        window.focus(&name_editor.focus_handle(cx), cx);
+
+        let description_editor = cx.new(|cx| {
+            InputField::new(
+                window,
+                cx,
+                "e.g., Fill the PR description following this template.",
+            )
+            .label("Description")
+            .tab_index(DESCRIPTION_FIELD_TAB_INDEX)
+            .tab_stop(true)
+        });
+
+        let body_editor = cx.new(|cx| {
+            let buffer = cx.new(|cx| {
+                let buffer = Buffer::local(String::new(), cx);
+                buffer.set_language_registry(language_registry.clone());
+                buffer
+            });
+            let mut editor = Editor::for_buffer(buffer, None, window, cx);
+            editor.set_placeholder_text("Add skill content…", window, cx);
+            editor.set_soft_wrap_mode(SoftWrap::EditorWidth, cx);
+            editor.set_show_gutter(false, cx);
+            editor.set_show_wrap_guides(false, cx);
+            editor.set_show_indent_guides(false, cx);
+            editor.set_use_modal_editing(true);
+            editor.set_current_line_highlight(Some(CurrentLineHighlight::None));
+            editor
+        });
+
+        // Attach Markdown language to the body editor asynchronously, since
+        // `language_for_name` returns a Task.
+        cx.spawn_in(window, {
+            let body_editor = body_editor.downgrade();
+            let language_registry = language_registry.clone();
+            async move |_this, cx| {
+                let markdown = language_registry.language_for_name("Markdown").await.ok();
+                if let Some(markdown) = markdown {
+                    body_editor
+                        .update(cx, |editor, cx| {
+                            editor.buffer().update(cx, |multi_buffer, cx| {
+                                if let Some(buffer) = multi_buffer.as_singleton() {
+                                    buffer.update(cx, |buffer, cx| {
+                                        buffer.set_language(Some(markdown), cx)
+                                    });
+                                }
+                            });
+                        })
+                        .ok();
+                }
+            }
+        })
+        .detach();
+
+        let name_input_editor = name_editor.read(cx).editor().clone();
+        let description_input_editor = description_editor.read(cx).editor().clone();
+        let weak = cx.weak_entity();
+        let name_subscription = name_input_editor.subscribe(
+            Box::new(move |event, window, cx| {
+                weak.update(cx, |this, cx| {
+                    this.handle_name_input_event(&event, window, cx);
+                })
+                .ok();
+            }),
+            window,
+            cx,
+        );
+        let weak = cx.weak_entity();
+        let description_subscription = description_input_editor.subscribe(
+            Box::new(move |event, window, cx| {
+                weak.update(cx, |this, cx| {
+                    this.handle_description_input_event(&event, window, cx);
+                })
+                .ok();
+            }),
+            window,
+            cx,
+        );
+
+        let subscriptions = vec![
+            name_subscription,
+            description_subscription,
+            cx.subscribe_in(&body_editor, window, Self::handle_body_editor_event),
+        ];
+
+        Self {
+            focus_handle,
+            title_bar: if !cfg!(target_os = "macos") {
+                Some(cx.new(|cx| PlatformTitleBar::new("skill-creator-title-bar", cx)))
+            } else {
+                None
+            },
+            workspace,
+            fs,
+            name_editor,
+            description_editor,
+            body_editor,
+            description_length: 0,
+            scopes,
+            selected_scope_key,
+            disable_model_invocation: false,
+            name_error: None,
+            description_error: None,
+            body_error: None,
+            save_error: None,
+            saving: false,
+            save_task: None,
+            _subscriptions: subscriptions,
+        }
+    }
+
+    fn handle_name_input_event(
+        &mut self,
+        event: &ErasedEditorEvent,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if matches!(event, ErasedEditorEvent::BufferEdited) {
+            self.recompute_name_error(cx);
+            self.save_error = None;
+            cx.notify();
+        }
+    }
+
+    fn handle_description_input_event(
+        &mut self,
+        event: &ErasedEditorEvent,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if matches!(event, ErasedEditorEvent::BufferEdited) {
+            self.recompute_description_error(cx);
+            self.save_error = None;
+            cx.notify();
+        }
+    }
+
+    fn handle_body_editor_event(
+        &mut self,
+        _: &Entity<Editor>,
+        event: &EditorEvent,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if matches!(event, EditorEvent::BufferEdited) {
+            self.recompute_body_error(cx);
+            self.save_error = None;
+            cx.notify();
+        }
+    }
+
+    fn current_name(&self, cx: &App) -> String {
+        self.name_editor.read(cx).text(cx)
+    }
+
+    fn current_description(&self, cx: &App) -> String {
+        self.description_editor.read(cx).text(cx)
+    }
+
+    fn current_body(&self, cx: &App) -> String {
+        self.body_editor.read(cx).text(cx)
+    }
+
+    fn recompute_name_error(&mut self, cx: &App) {
+        let name = self.current_name(cx);
+        self.name_error = validate_name(&name).err();
+    }
+
+    fn recompute_description_error(&mut self, cx: &App) {
+        let description = self.current_description(cx);
+        self.description_length = description.len();
+        self.description_error = validate_description(&description).err();
+    }
+
+    fn recompute_body_error(&mut self, cx: &App) {
+        let body = self.current_body(cx);
+        self.body_error = if body.trim().is_empty() {
+            Some("Body is required.")
+        } else {
+            None
+        };
+    }
+
+    fn is_valid(&self, cx: &App) -> bool {
+        validate_name(&self.current_name(cx)).is_ok()
+            && validate_description(&self.current_description(cx)).is_ok()
+            && !self.current_body(cx).trim().is_empty()
+            && self.selected_scope().is_some()
+    }
+
+    fn selected_scope(&self) -> Option<&ScopeChoice> {
+        self.scopes
+            .iter()
+            .find(|scope| scope.key() == self.selected_scope_key)
+    }
+
+    fn save_skill(&mut self, _: &SaveSkill, window: &mut Window, cx: &mut Context<Self>) {
+        // Surface any field-level errors before attempting to save.
+        self.recompute_name_error(cx);
+        self.recompute_description_error(cx);
+        self.recompute_body_error(cx);
+
+        if !self.is_valid(cx) || self.saving {
+            cx.notify();
+            return;
+        }
+
+        let Some(scope) = self.selected_scope().cloned() else {
+            self.save_error = Some("Select a scope to save this skill to.".into());
+            cx.notify();
+            return;
+        };
+
+        let name = self.current_name(cx);
+        let description = self.current_description(cx);
+        let body = self.current_body(cx);
+        let disable_model_invocation = self.disable_model_invocation;
+        let fs = self.fs.clone();
+        let workspace = self.workspace.clone();
+        let scope_label = scope.label();
+
+        self.saving = true;
+        self.save_error = None;
+        cx.notify();
+
+        let task = cx.spawn_in(window, async move |this, cx| {
+            let result = write_skill_to_disk(
+                fs.as_ref(),
+                &scope.skills_dir(),
+                &name,
+                &description,
+                &body,
+                disable_model_invocation,
+            )
+            .await;
+
+            this.update_in(cx, |this, window, cx| {
+                this.saving = false;
+                this.save_task = None;
+                match result {
+                    Ok(path) => {
+                        if let Some(workspace) = workspace.as_ref().and_then(|w| w.upgrade()) {
+                            workspace.update(cx, |workspace, cx| {
+                                workspace.show_toast(
+                                    Toast::new(
+                                        NotificationId::unique::<SaveSkill>(),
+                                        format!(
+                                            "Saved skill \"{name}\" to {scope_label} ({})",
+                                            path.display()
+                                        ),
+                                    ),
+                                    cx,
+                                );
+                            });
+                        }
+                        window.remove_window();
+                    }
+                    Err(err) => {
+                        this.save_error = Some(SharedString::from(err.to_string()));
+                        cx.notify();
+                    }
+                }
+            })
+            .log_err();
+        });
+        self.save_task = Some(task);
+    }
+
+    fn cancel(&mut self, _: &Cancel, window: &mut Window, _cx: &mut Context<Self>) {
+        // Block dismissal while a save is in flight. Otherwise the
+        // detached I/O could complete after the window is gone, leaving
+        // a SKILL.md on disk with no success or error feedback. The
+        // user can still force-close the window via the platform
+        // chrome, in which case dropping `self.save_task` cancels the
+        // pending write.
+        if self.saving {
+            return;
+        }
+        window.remove_window();
+    }
+
+    fn select_scope(&mut self, key: SharedString, cx: &mut Context<Self>) {
+        if self.scopes.iter().any(|scope| scope.key() == key) {
+            self.selected_scope_key = key;
+            self.save_error = None;
+            cx.notify();
+        }
+    }
+
+    fn toggle_disable_model_invocation(&mut self, cx: &mut Context<Self>) {
+        self.disable_model_invocation = !self.disable_model_invocation;
+        cx.notify();
+    }
+
+    fn render_scope_field(&self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let scopes = self.scopes.clone();
+        let selected = self.selected_scope().cloned();
+        let selected_label: SharedString = match selected.as_ref() {
+            Some(ScopeChoice::Global) => "Global".into(),
+            Some(ScopeChoice::Project { root_name, .. }) => {
+                SharedString::from(format!("{root_name} (project)"))
+            }
+            None => "Select a scope\u{2026}".into(),
+        };
+        let sep = std::path::MAIN_SEPARATOR;
+        let scope_hint: SharedString = match selected.as_ref() {
+            Some(ScopeChoice::Global) => SharedString::from(format!(
+                "Available across every Zed project. \
+                Saved to {GLOBAL_SKILLS_DIR_DISPLAY}{sep}\u{2039}name\u{203A}{sep}{SKILL_FILE_NAME}."
+            )),
+            Some(ScopeChoice::Project { root_name, .. }) => SharedString::from(format!(
+                "Only available when this project is open. \
+                Saved to {root_name}{sep}{AGENTS_DIR_NAME}{sep}{SKILLS_DIR_NAME}{sep}\u{2039}name\u{203A}{sep}{SKILL_FILE_NAME}."
+            )),
+            None => "Choose where this skill should live.".into(),
+        };
+
+        let selected_label = h_flex()
+            .min_w_0()
+            .w_full()
+            .child(Label::new(selected_label).truncate())
+            .into_any_element();
+
+        let weak = cx.weak_entity();
+
+        let menu = ContextMenu::build(window, cx, move |mut menu, _window, _cx| {
+            for scope in &scopes {
+                let key = scope.key();
+                let weak = weak.clone();
+                let entry_label: SharedString = match scope {
+                    ScopeChoice::Global => "Global".into(),
+                    ScopeChoice::Project { root_name, .. } => {
+                        SharedString::from(format!("{root_name} (project)"))
+                    }
+                };
+                menu = menu.entry(entry_label, None, move |_window, cx| {
+                    weak.update(cx, |this, cx| {
+                        this.select_scope(key.clone(), cx);
+                    })
+                    .log_err();
+                });
+            }
+            menu
+        });
+
+        h_flex()
+            .min_w_0()
+            .w_full()
+            .gap_6()
+            .justify_between()
+            .child(
+                v_flex()
+                    .flex_1()
+                    .min_w_0()
+                    .child(Label::new("Scope"))
+                    .child(Label::new(scope_hint).color(Color::Muted)),
+            )
+            .child(
+                div().w_1_3().min_w_0().child(
+                    DropdownMenu::new_with_element("skill-scope-dropdown", selected_label, menu)
+                        .tab_index(SCOPE_FIELD_TAB_INDEX)
+                        .style(DropdownStyle::Outlined)
+                        .trigger_size(ButtonSize::Medium)
+                        .full_width(true),
+                ),
+            )
+    }
+
+    fn render_optional_params(&self, cx: &mut Context<Self>) -> impl IntoElement {
+        let toggle_state: ToggleState = self.disable_model_invocation.into();
+
+        SwitchField::new(
+            "disable-model-invocation",
+            Some("Disable model invocation"),
+            Some(
+                "Hide this skill from the model's catalog. It can still be invoked via slash command."
+                    .into(),
+            ),
+            toggle_state,
+            cx.listener(|this, _state: &ToggleState, _window, cx| {
+                this.toggle_disable_model_invocation(cx);
+            }),
+        )
+        .tab_index(DISABLE_MODEL_INVOCATION_TAB_INDEX).into_any_element()
+    }
+
+    fn render_body_field(&self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let settings = ThemeSettings::get_global(cx);
+        let theme = cx.theme().clone();
+
+        let has_error = self.body_error.is_some();
+
+        let focus_handle = self
+            .body_editor
+            .focus_handle(cx)
+            .tab_index(BODY_FIELD_TAB_INDEX)
+            .tab_stop(true);
+
+        let border_color = if has_error {
+            theme.status().error_border
+        } else if focus_handle.contains_focused(window, cx) {
+            theme.colors().border_focused
+        } else {
+            theme.colors().border
+        };
+
+        div()
+            .w_full()
+            .flex_1()
+            .min_h(px(160.))
+            .p_2p5()
+            .rounded_md()
+            .border_1()
+            .border_color(border_color)
+            .bg(theme.colors().editor_background)
+            .track_focus(&focus_handle)
+            .overflow_hidden()
+            .child(EditorElement::new(
+                &self.body_editor,
+                EditorStyle {
+                    local_player: theme.players().local(),
+                    text: TextStyle {
+                        color: theme.colors().text,
+                        font_family: settings.buffer_font.family.clone(),
+                        font_features: settings.buffer_font.features.clone(),
+                        font_size: rems(0.875).into(),
+                        font_weight: settings.buffer_font.weight,
+                        line_height: relative(settings.buffer_line_height.value()),
+                        ..Default::default()
+                    },
+                    syntax: theme.syntax().clone(),
+                    inlay_hints_style: editor::make_inlay_hints_style(cx),
+                    edit_prediction_styles: editor::make_suggestion_styles(cx),
+                    ..EditorStyle::default()
+                },
+            ))
+    }
+
+    fn render_action_bar(&self, cx: &mut Context<Self>) -> impl IntoElement {
+        let valid = self.is_valid(cx);
+        let saving = self.saving;
+        let main_action = if saving { "Saving…" } else { "Save Skill" };
+
+        h_flex()
+            .w_full()
+            .map(|this| {
+                if self.save_error.is_some() {
+                    this.justify_between()
+                } else {
+                    this.justify_end()
+                }
+            })
+            .gap_2()
+            .children(
+                self.save_error
+                    .clone()
+                    .map(|err| Label::new(err).size(LabelSize::Small).color(Color::Error)),
+            )
+            .child(
+                h_flex()
+                    .gap_1()
+                    .child(
+                        Button::new("cancel-skill", "Cancel")
+                            .disabled(saving)
+                            .on_click(|_, window, cx| {
+                                window.dispatch_action(Box::new(Cancel), cx);
+                            }),
+                    )
+                    .child(
+                        Button::new("save-skill", main_action)
+                            .style(ButtonStyle::Filled)
+                            .layer(ui::ElevationIndex::ModalSurface)
+                            .disabled(!valid || saving)
+                            .loading(saving)
+                            .on_click(|_, window, cx| {
+                                window.dispatch_action(Box::new(SaveSkill), cx);
+                            }),
+                    ),
+            )
+    }
+
+    fn render_header(&self, cx: &mut Context<Self>) -> impl IntoElement {
+        let theme = cx.theme().clone();
+        let needs_traffic_light_clearance = cfg!(target_os = "macos");
+
+        h_flex()
+            .w_full()
+            .h_10()
+            .px_4()
+            .when(needs_traffic_light_clearance, |this| this.pl(px(84.)))
+            .border_b_1()
+            .border_color(theme.colors().border)
+            .child(Headline::new("Skill Creator").size(HeadlineSize::XSmall))
+    }
+
+    fn focus_next_field(
+        &mut self,
+        _: &FocusNextField,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        window.focus_next(cx);
+    }
+
+    fn focus_previous_field(
+        &mut self,
+        _: &FocusPreviousField,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        window.focus_prev(cx);
+    }
+
+    // When focus is on a non-editor tab stop (dropdown button, switch),
+    // Tab dispatches the global `menu::SelectNext` rather than our
+    // custom `FocusNextField`. Catching it here keeps the cycle moving.
+    fn on_menu_next(&mut self, _: &menu::SelectNext, window: &mut Window, cx: &mut Context<Self>) {
+        window.focus_next(cx);
+    }
+
+    fn on_menu_prev(
+        &mut self,
+        _: &menu::SelectPrevious,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        window.focus_prev(cx);
+    }
+}
+
+impl Focusable for SkillCreator {
+    fn focus_handle(&self, _cx: &App) -> FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Render for SkillCreator {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let ui_font = theme_settings::setup_ui_font(window, cx);
+        let theme = cx.theme().clone();
+
+        client_side_decorations(
+            v_flex()
+                .id("skill-creator")
+                .key_context("SkillCreator")
+                .track_focus(&self.focus_handle)
+                .on_action(
+                    |action_sequence: &ActionSequence, window: &mut Window, cx: &mut App| {
+                        for action in &action_sequence.0 {
+                            window.dispatch_action(action.boxed_clone(), cx);
+                        }
+                    },
+                )
+                .on_action(cx.listener(Self::save_skill))
+                .on_action(cx.listener(Self::cancel))
+                .on_action(cx.listener(Self::focus_next_field))
+                .on_action(cx.listener(Self::focus_previous_field))
+                .on_action(cx.listener(Self::on_menu_next))
+                .on_action(cx.listener(Self::on_menu_prev))
+                .size_full()
+                .overflow_hidden()
+                .font(ui_font)
+                .text_color(theme.colors().text)
+                .bg(theme.colors().panel_background)
+                .children(self.title_bar.clone())
+                .child(self.render_header(cx))
+                .child(
+                    v_flex()
+                        .id("skill-creator-form")
+                        .tab_index(0)
+                        .tab_group()
+                        .tab_stop(false)
+                        .flex_1()
+                        .min_h_0()
+                        .gap_4()
+                        .p_4()
+                        .child(
+                            v_flex()
+                                .gap_2()
+                                .child(Label::new("Font-matter"))
+                                .child(self.name_editor.clone())
+                                .child(self.description_editor.clone()),
+                        )
+                        .child(self.render_optional_params(cx))
+                        .child(Divider::horizontal())
+                        .child(self.render_scope_field(window, cx))
+                        .child(Divider::horizontal())
+                        .child(
+                            v_flex()
+                                .flex_1()
+                                .gap_2()
+                                .child(Label::new("Skill Content"))
+                                .child(self.render_body_field(window, cx)),
+                        ),
+                )
+                .child(
+                    h_flex()
+                        .w_full()
+                        .p_2p5()
+                        .border_t_1()
+                        .border_color(theme.colors().border_variant)
+                        .bg(theme.colors().panel_background)
+                        .child(self.render_action_bar(cx)),
+                ),
+            window,
+            cx,
+            Tiling::default(),
+        )
+    }
+}
+
+/// Serialize the SKILL.md file to disk at `<skills_dir>/<name>/SKILL.md`.
+///
+/// Refuses to overwrite an existing directory at `<skills_dir>/<name>`. The
+/// caller surfaces the resulting error to the user, who picks a different
+/// name.
+async fn write_skill_to_disk(
+    fs: &dyn Fs,
+    skills_dir: &std::path::Path,
+    name: &str,
+    description: &str,
+    body: &str,
+    disable_model_invocation: bool,
+) -> Result<PathBuf> {
+    let skill_dir = skills_dir.join(name);
+    match fs.metadata(&skill_dir).await {
+        Ok(Some(metadata)) if metadata.is_dir => {
+            anyhow::bail!(
+                "A skill named \"{name}\" already exists at {}. Pick a different name.",
+                skill_dir.display()
+            );
+        }
+        Ok(Some(_)) => {
+            // Something exists at this path, but it isn't a directory — e.g.
+            // a stray file the user (or another tool) left there. Without
+            // this branch we'd fall through to `create_dir`, which on the
+            // real fs returns a generic "File exists" IO error that gives
+            // the user no idea what's wrong or how to recover.
+            anyhow::bail!(
+                "A file (not a skill directory) already exists at {}. \
+                 Delete it or pick a different skill name.",
+                skill_dir.display()
+            );
+        }
+        Ok(None) => {}
+        Err(err) => {
+            return Err(err).with_context(|| {
+                format!(
+                    "failed to check whether {} already exists",
+                    skill_dir.display()
+                )
+            });
+        }
+    }
+
+    let content = format_skill_file(name, description, body, disable_model_invocation)?;
+
+    fs.create_dir(&skill_dir)
+        .await
+        .with_context(|| format!("failed to create skill directory {}", skill_dir.display()))?;
+    let skill_file_path = skill_dir.join(SKILL_FILE_NAME);
+    fs.write(&skill_file_path, content.as_bytes())
+        .await
+        .with_context(|| format!("failed to write {}", skill_file_path.display()))?;
+
+    Ok(skill_file_path)
+}
+
+fn format_skill_file(
+    name: &str,
+    description: &str,
+    body: &str,
+    disable_model_invocation: bool,
+) -> Result<String> {
+    let metadata = SkillMetadata {
+        name: name.to_string(),
+        description: description.to_string(),
+        disable_model_invocation,
+    };
+    let frontmatter = serde_yaml_ng::to_string(&metadata)
+        .context("failed to serialize skill frontmatter as YAML")?;
+
+    let mut content = String::with_capacity(frontmatter.len() + body.len() + 16);
+    content.push_str("---\n");
+    content.push_str(&frontmatter);
+    content.push_str("---\n");
+    let trimmed_body = body.trim();
+    if !trimmed_body.is_empty() {
+        content.push('\n');
+        content.push_str(trimmed_body);
+        content.push('\n');
+    }
+    Ok(content)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use agent_skills::{SkillSource, parse_skill_frontmatter};
+    use fs::FakeFs;
+    use std::path::Path;
+
+    // Name and description validation rules are unit-tested in
+    // `agent_skills`, which owns `validate_name` / `validate_description`
+    // / `MAX_SKILL_DESCRIPTION_LEN`. The tests below cover this crate's
+    // own surface area: SKILL.md formatting and disk-writing.
+
+    #[test]
+    fn format_skill_file_round_trips_through_parser() {
+        let content =
+            format_skill_file("draft-pr", "Push a draft PR", "Do the thing.", false).unwrap();
+        let skill = parse_skill_frontmatter(
+            Path::new("/skills/draft-pr/SKILL.md"),
+            &content,
+            SkillSource::Global,
+        )
+        .expect("generated frontmatter must round-trip through parse_skill_frontmatter");
+        assert_eq!(skill.name, "draft-pr");
+        assert_eq!(skill.description, "Push a draft PR");
+        assert!(!skill.disable_model_invocation);
+    }
+
+    #[test]
+    fn format_skill_file_writes_disable_model_invocation_true() {
+        let content = format_skill_file("my-skill", "description", "body", true).unwrap();
+        assert!(content.contains("disable-model-invocation: true"));
+    }
+
+    #[test]
+    fn format_skill_file_omits_body_when_empty() {
+        let content = format_skill_file("my-skill", "description", "   ", false).unwrap();
+        // The trailing closing-delimiter newline is the last byte.
+        assert!(content.ends_with("---\n"));
+    }
+
+    #[test]
+    fn format_skill_file_escapes_yaml_specials_in_description() {
+        // serde_yaml_ng must quote/escape descriptions that contain YAML
+        // specials so the file round-trips. If we ever swap formatters,
+        // this test will catch a regression.
+        let tricky = "contains: a colon, # a hash, and a \"quote\"";
+        let content = format_skill_file("weird-skill", tricky, "body", false).unwrap();
+        let skill = parse_skill_frontmatter(
+            Path::new("/skills/weird-skill/SKILL.md"),
+            &content,
+            SkillSource::Global,
+        )
+        .expect("YAML-special characters must round-trip");
+        assert_eq!(skill.description, tricky);
+    }
+
+    #[gpui::test]
+    async fn write_skill_to_disk_creates_directory_and_file(cx: &mut gpui::TestAppContext) {
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree("/skills", serde_json::json!({})).await;
+
+        let path = write_skill_to_disk(
+            fs.as_ref(),
+            Path::new("/skills"),
+            "draft-pr",
+            "Push a draft PR",
+            "Body of the skill.",
+            false,
+        )
+        .await
+        .expect("write should succeed");
+
+        assert_eq!(path, Path::new("/skills/draft-pr/SKILL.md"));
+        let content = fs.load(&path).await.expect("file should exist");
+        let skill = parse_skill_frontmatter(&path, &content, SkillSource::Global)
+            .expect("written file should be parseable");
+        assert_eq!(skill.name, "draft-pr");
+        assert_eq!(skill.description, "Push a draft PR");
+    }
+
+    #[gpui::test]
+    async fn write_skill_to_disk_refuses_to_overwrite(cx: &mut gpui::TestAppContext) {
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(
+            "/skills",
+            serde_json::json!({
+                "draft-pr": {
+                    "SKILL.md": "---\nname: draft-pr\ndescription: existing\n---\nbody\n"
+                }
+            }),
+        )
+        .await;
+
+        let err = write_skill_to_disk(
+            fs.as_ref(),
+            Path::new("/skills"),
+            "draft-pr",
+            "Push a draft PR",
+            "Body of the skill.",
+            false,
+        )
+        .await
+        .expect_err("writing over an existing skill must fail");
+        assert!(
+            err.to_string().contains("already exists"),
+            "error message should mention the conflict, got: {err}"
+        );
+    }
+
+    #[gpui::test]
+    async fn write_skill_to_disk_rejects_non_directory_at_skill_path(
+        cx: &mut gpui::TestAppContext,
+    ) {
+        let fs = FakeFs::new(cx.executor());
+        // A *file* (not a directory) sitting at `/skills/draft-pr`. With the
+        // old `is_dir` check this slipped through and we ended up surfacing
+        // the underlying "File exists" OS error.
+        fs.insert_tree(
+            "/skills",
+            serde_json::json!({ "draft-pr": "i am a stray file" }),
+        )
+        .await;
+
+        let err = write_skill_to_disk(
+            fs.as_ref(),
+            Path::new("/skills"),
+            "draft-pr",
+            "Push a draft PR",
+            "Body of the skill.",
+            false,
+        )
+        .await
+        .expect_err("writing where a file already lives must fail");
+        let message = err.to_string();
+        assert!(
+            message.contains("not a skill directory"),
+            "error should explain the conflict is a non-directory, got: {message}"
+        );
+        // Path separator differs between platforms (`/` on Unix, `\` on
+        // Windows), so reconstruct the expected `Display` form rather than
+        // hard-coding a separator.
+        let expected_path = Path::new("/skills").join("draft-pr");
+        let expected_path = expected_path.display().to_string();
+        assert!(
+            message.contains(&expected_path),
+            "error should include the conflicting path {expected_path:?}, got: {message}"
+        );
+    }
+}
diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs
index fedf9d8cf24..17c910ab024 100644
--- a/crates/zed/src/zed.rs
+++ b/crates/zed/src/zed.rs
@@ -5253,6 +5253,7 @@ mod tests {
                 "search",
                 "settings_editor",
                 "settings_profile_selector",
+                "skill_creator",
                 "snippets",
                 "stash_picker",
                 "svg",
diff --git a/crates/zed_actions/src/lib.rs b/crates/zed_actions/src/lib.rs
index da51f3ccc75..8390cda86c7 100644
--- a/crates/zed_actions/src/lib.rs
+++ b/crates/zed_actions/src/lib.rs
@@ -570,6 +570,8 @@ pub mod assistant {
             #[action(deprecated_aliases = ["assistant::ToggleFocus"])]
             ToggleFocus,
             FocusAgent,
+            /// Opens the skill creator window for creating a new skill.
+            OpenSkillCreator,
         ]
     );
 

From 068d64edd637be2e7e2a44b99ef4965550885b67 Mon Sep 17 00:00:00 2001
From: Liber <liberxue@gmail.com>
Date: Wed, 20 May 2026 11:39:36 +0800
Subject: [PATCH 053/105] vim: Fix n/N and */# selecting text after cmd+f
 search (#54027)

The cmd_f_search flag introduced in #51073 was never cleared when
switching to vim-style search commands, causing collapse_matches to
remain false and match ranges to appear as visual selections.

Reset cmd_f_search when n/N or */# are used, restore Normal mode if
Visual was entered due to the non-collapsed selection, and fix an early
return in visual select_match that leaked collapse_matches.

Fixes #53896

Self-Review Checklist:

- [ ] I've reviewed my own diff for quality, security, and reliability
- [ ] Unsafe blocks (if any) have justifying comments
- [ ] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [ ] Tests cover the new/changed behavior
- [ ] Performance impact has been considered and is acceptable

Closes #ISSUE

Release Notes:

- N/A or Added/Fixed/Improved ...

Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com>
---
 crates/vim/src/normal/search.rs | 58 +++++++++++++++++++++++++++++++++
 crates/vim/src/visual.rs        |  3 ++
 2 files changed, 61 insertions(+)

diff --git a/crates/vim/src/normal/search.rs b/crates/vim/src/normal/search.rs
index 1ebf51aa293..92baae1d37f 100644
--- a/crates/vim/src/normal/search.rs
+++ b/crates/vim/src/normal/search.rs
@@ -389,6 +389,15 @@ impl Vim {
         };
         let count = Vim::take_count(cx).unwrap_or(1);
         Vim::take_forced_motion(cx);
+
+        if self.search.cmd_f_search {
+            self.search.cmd_f_search = false;
+            if self.mode.is_visual() {
+                self.switch_mode(Mode::Normal, false, window, cx);
+            }
+            self.sync_vim_settings(window, cx);
+        }
+
         let prior_selections = self.editor_selections(window, cx);
 
         let success = pane.update(cx, |pane, cx| {
@@ -433,6 +442,15 @@ impl Vim {
         };
         let count = Vim::take_count(cx).unwrap_or(1);
         Vim::take_forced_motion(cx);
+
+        if self.search.cmd_f_search {
+            self.search.cmd_f_search = false;
+            if self.mode.is_visual() {
+                self.switch_mode(Mode::Normal, false, window, cx);
+            }
+            self.sync_vim_settings(window, cx);
+        }
+
         let prior_selections = self.editor_selections(window, cx);
         let vim = cx.entity();
 
@@ -1017,6 +1035,46 @@ mod test {
         cx.assert_state("one «oneˇ» one one", Mode::Insert);
     }
 
+    #[gpui::test]
+    async fn test_n_after_cmd_f_search(cx: &mut gpui::TestAppContext) {
+        let mut cx = VimTestContext::new(cx, true).await;
+        cx.set_state("ˇone two one two one", Mode::Normal);
+        cx.run_until_parked();
+
+        // Use cmd+f to search (non-vim style)
+        cx.simulate_keystrokes("cmd-f");
+        cx.run_until_parked();
+        cx.simulate_keystrokes("escape");
+        cx.run_until_parked();
+
+        // Now use n to go to next match — should move cursor, not create selection
+        cx.simulate_keystrokes("n");
+        cx.run_until_parked();
+        cx.assert_state("one two ˇone two one", Mode::Normal);
+
+        cx.simulate_keystrokes("n");
+        cx.run_until_parked();
+        cx.assert_state("one two one two ˇone", Mode::Normal);
+    }
+
+    #[gpui::test]
+    async fn test_star_after_cmd_f_search(cx: &mut gpui::TestAppContext) {
+        let mut cx = VimTestContext::new(cx, true).await;
+        cx.set_state("ˇone two one two one", Mode::Normal);
+        cx.run_until_parked();
+
+        // Use cmd+f to search (non-vim style)
+        cx.simulate_keystrokes("cmd-f");
+        cx.run_until_parked();
+        cx.simulate_keystrokes("escape");
+        cx.run_until_parked();
+
+        // Now use * to search under cursor — should move cursor, not create selection
+        cx.simulate_keystrokes("*");
+        cx.run_until_parked();
+        cx.assert_state("one two ˇone two one", Mode::Normal);
+    }
+
     #[gpui::test]
     async fn test_visual_star_hash(cx: &mut gpui::TestAppContext) {
         let mut cx = NeovimBackedTestContext::new(cx).await;
diff --git a/crates/vim/src/visual.rs b/crates/vim/src/visual.rs
index bc53167b158..077e098bb3a 100644
--- a/crates/vim/src/visual.rs
+++ b/crates/vim/src/visual.rs
@@ -897,6 +897,9 @@ impl Vim {
             }
         });
         if !match_exists {
+            self.update_editor(cx, |_, editor, _| {
+                editor.set_collapse_matches(true);
+            });
             self.clear_operator(window, cx);
             self.stop_replaying(cx);
             return;

From 0f6ebdd26908734c505597dac4f82546f75129f0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=20Houl=C3=A9?=
 <13155277+tomhoule@users.noreply.github.com>
Date: Wed, 20 May 2026 08:58:10 +0200
Subject: [PATCH 054/105] cli: Respect `--new` when opening URLs from the CLI
 (#54408)

`zed --new ssh://host/path/to/file` only created a new window on the
first call. Subsequent invocations silently reused the existing SSH
workspace for the same host, which then tried to open the new path
against the existing worktree and surfaced a
`DevServerProjectPathDoesNotExist` popup when the path didn't belong to
any open worktree.

The CLI correctly translated `--new` to `OpenBehavior::AlwaysNew`, but
the URL branch of `handle_cli_connection` dropped the `open_behavior`.
`handle_open_request` then called `open_remote_project` (and
`open_paths_with_positions` for `file://`) with
`OpenOptions::default()`, which is `WorkspaceMatching::MatchExact`, so
any existing SSH window for the same host won the match. The issue
applies to `file://` URLs and `-a` / `-e` / `--reuse` for URL-shaped
arguments in general; `--new` was just the most visible symptom.

The fix is making sure the translation of `OpenRequest` is uniform
across plain paths and URL-shaped arguments.

Closes #52679.

Release Notes:

- Fixed `zed --new ssh://host/path` reusing an existing SSH window
instead of opening a new one. This also applied to other URL-shaped path
arguments.
---
 crates/zed/src/main.rs              |  27 +++--
 crates/zed/src/zed/open_listener.rs | 167 +++++++++++++++++++++++-----
 2 files changed, 155 insertions(+), 39 deletions(-)

diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index 4cbbf700f57..3042510f2c6 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -909,6 +909,7 @@ fn main() {
                 wsl,
                 diff_all: diff_all_mode,
                 dev_container: args.dev_container,
+                ..Default::default()
             })
         }
 
@@ -1264,6 +1265,11 @@ fn handle_open_request(request: OpenRequest, app_state: Arc<AppState>, cx: &mut
                 });
             }
             OpenRequestKind::GitCommit { sha } => {
+                let base_open_options = zed::open_options_for_request(
+                    request.open_behavior,
+                    &workspace::SerializedWorkspaceLocation::Local,
+                    cx,
+                );
                 cx.spawn(async move |cx| {
                     let paths_with_position =
                         derive_paths_with_position(app_state.fs.as_ref(), request.open_paths).await;
@@ -1272,7 +1278,7 @@ fn handle_open_request(request: OpenRequest, app_state: Arc<AppState>, cx: &mut
                         &[],
                         false,
                         app_state,
-                        workspace::OpenOptions::default(),
+                        base_open_options,
                         cx,
                     )
                     .await?;
@@ -1314,16 +1320,12 @@ fn handle_open_request(request: OpenRequest, app_state: Arc<AppState>, cx: &mut
     }
 
     if let Some(connection_options) = request.remote_connection {
+        let open_behavior = request.open_behavior;
+        let location = workspace::SerializedWorkspaceLocation::Remote(connection_options.clone());
+        let base_open_options = zed::open_options_for_request(open_behavior, &location, cx);
         cx.spawn(async move |cx| {
             let paths: Vec<PathBuf> = request.open_paths.into_iter().map(PathBuf::from).collect();
-            open_remote_project(
-                connection_options,
-                paths,
-                app_state,
-                workspace::OpenOptions::default(),
-                cx,
-            )
-            .await
+            open_remote_project(connection_options, paths, app_state, base_open_options, cx).await
         })
         .detach_and_log_err(cx);
         return;
@@ -1333,6 +1335,11 @@ fn handle_open_request(request: OpenRequest, app_state: Arc<AppState>, cx: &mut
     let dev_container = request.dev_container;
     if !request.open_paths.is_empty() || !request.diff_paths.is_empty() {
         let app_state = app_state.clone();
+        let base_open_options = zed::open_options_for_request(
+            request.open_behavior,
+            &workspace::SerializedWorkspaceLocation::Local,
+            cx,
+        );
         task = Some(cx.spawn(async move |cx| {
             let paths_with_position =
                 derive_paths_with_position(app_state.fs.as_ref(), request.open_paths).await;
@@ -1343,7 +1350,7 @@ fn handle_open_request(request: OpenRequest, app_state: Arc<AppState>, cx: &mut
                 app_state,
                 workspace::OpenOptions {
                     open_in_dev_container: dev_container,
-                    ..Default::default()
+                    ..base_open_options
                 },
                 cx,
             )
diff --git a/crates/zed/src/zed/open_listener.rs b/crates/zed/src/zed/open_listener.rs
index 1544b877dcc..4a4f5fca518 100644
--- a/crates/zed/src/zed/open_listener.rs
+++ b/crates/zed/src/zed/open_listener.rs
@@ -42,6 +42,7 @@ pub struct OpenRequest {
     pub open_channel_notes: Vec<(u64, Option<String>)>,
     pub join_channel: Option<u64>,
     pub remote_connection: Option<RemoteConnectionOptions>,
+    pub open_behavior: Option<cli::OpenBehavior>,
 }
 
 pub enum OpenRequestKind {
@@ -135,6 +136,7 @@ impl OpenRequest {
         this.diff_paths = request.diff_paths;
         this.diff_all = request.diff_all;
         this.dev_container = request.dev_container;
+        this.open_behavior = request.open_behavior;
         if let Some(wsl) = request.wsl {
             let (user, distro_name) = if let Some((user, distro)) = wsl.split_once('@') {
                 if user.is_empty() {
@@ -382,6 +384,7 @@ pub struct RawOpenRequest {
     pub diff_all: bool,
     pub dev_container: bool,
     pub wsl: Option<String>,
+    pub open_behavior: Option<cli::OpenBehavior>,
 }
 
 impl Global for OpenListener {}
@@ -571,6 +574,7 @@ pub async fn handle_cli_connection(
                                 diff_all,
                                 dev_container,
                                 wsl,
+                                open_behavior: Some(open_behavior),
                             },
                             cx,
                         ) {
@@ -735,6 +739,52 @@ async fn resolve_open_behavior(
     None
 }
 
+pub(crate) fn open_options_for_request(
+    open_behavior: Option<cli::OpenBehavior>,
+    location: &SerializedWorkspaceLocation,
+    cx: &App,
+) -> workspace::OpenOptions {
+    open_behavior.map_or_else(workspace::OpenOptions::default, |open_behavior| {
+        open_options_for_behavior(open_behavior, location, cx)
+    })
+}
+
+pub(crate) fn open_options_for_behavior(
+    open_behavior: cli::OpenBehavior,
+    location: &SerializedWorkspaceLocation,
+    cx: &App,
+) -> workspace::OpenOptions {
+    // If reuse flag is passed, open a new workspace in an existing window.
+    let requesting_window = if open_behavior == cli::OpenBehavior::Reuse {
+        workspace::workspace_windows_for_location(location, cx)
+            .into_iter()
+            .next()
+    } else {
+        None
+    };
+    workspace::OpenOptions {
+        workspace_matching: match open_behavior {
+            cli::OpenBehavior::AlwaysNew | cli::OpenBehavior::Reuse => {
+                workspace::WorkspaceMatching::None
+            }
+            cli::OpenBehavior::Add => workspace::WorkspaceMatching::MatchSubdirectory,
+            _ => workspace::WorkspaceMatching::MatchExact,
+        },
+        add_dirs_to_sidebar: match open_behavior {
+            cli::OpenBehavior::ExistingWindow => true,
+            // For the default value, we consult the settings to decide
+            // whether to open in a new window or existing window.
+            cli::OpenBehavior::Default => {
+                workspace::WorkspaceSettings::get_global(cx).cli_default_open_behavior
+                    == settings::CliDefaultOpenBehavior::ExistingWindow
+            }
+            _ => false,
+        },
+        requesting_window,
+        ..Default::default()
+    }
+}
+
 async fn open_workspaces(
     paths: Vec<String>,
     diff_paths: Vec<[String; 2]>,
@@ -787,39 +837,13 @@ async fn open_workspaces(
     let mut errored = false;
 
     for (location, workspace_paths) in grouped_locations {
-        // If reuse flag is passed, open a new workspace in an existing window.
-        let replace_window = if open_behavior == cli::OpenBehavior::Reuse {
-            cx.update(|cx| {
-                workspace::workspace_windows_for_location(&location, cx)
-                    .into_iter()
-                    .next()
-            })
-        } else {
-            None
-        };
+        let base_open_options =
+            cx.update(|cx| open_options_for_behavior(open_behavior, &location, cx));
         let open_options = workspace::OpenOptions {
-            workspace_matching: match open_behavior {
-                cli::OpenBehavior::AlwaysNew | cli::OpenBehavior::Reuse => {
-                    workspace::WorkspaceMatching::None
-                }
-                cli::OpenBehavior::Add => workspace::WorkspaceMatching::MatchSubdirectory,
-                _ => workspace::WorkspaceMatching::MatchExact,
-            },
-            add_dirs_to_sidebar: match open_behavior {
-                cli::OpenBehavior::ExistingWindow => true,
-                // For the default value, we consult the settings to decide
-                // whether to open in a new window or existing window.
-                cli::OpenBehavior::Default => cx.update(|cx| {
-                    workspace::WorkspaceSettings::get_global(cx).cli_default_open_behavior
-                        == settings::CliDefaultOpenBehavior::ExistingWindow
-                }),
-                _ => false,
-            },
-            requesting_window: replace_window,
             wait,
             env: env.clone(),
             open_in_dev_container: dev_container,
-            ..Default::default()
+            ..base_open_options
         };
 
         match location {
@@ -1160,6 +1184,25 @@ mod tests {
         }
     }
 
+    #[gpui::test]
+    fn test_parse_ssh_url_preserves_open_behavior(cx: &mut TestAppContext) {
+        let _app_state = init_test(cx);
+
+        let request = cx.update(|cx| {
+            OpenRequest::parse(
+                RawOpenRequest {
+                    urls: vec!["ssh://me@host:/".into()],
+                    open_behavior: Some(cli::OpenBehavior::AlwaysNew),
+                    ..Default::default()
+                },
+                cx,
+            )
+            .unwrap()
+        });
+
+        assert_eq!(request.open_behavior, Some(cli::OpenBehavior::AlwaysNew));
+    }
+
     #[gpui::test]
     fn test_reject_ssh_urls(cx: &mut TestAppContext) {
         let _app_state = init_test(cx);
@@ -1182,6 +1225,24 @@ mod tests {
         }
     }
 
+    #[gpui::test]
+    fn test_open_options_for_behavior_always_new(cx: &mut TestAppContext) {
+        let _app_state = init_test(cx);
+        let options = cx.update(|cx| {
+            open_options_for_behavior(
+                cli::OpenBehavior::AlwaysNew,
+                &SerializedWorkspaceLocation::Local,
+                cx,
+            )
+        });
+        assert_eq!(
+            options.workspace_matching,
+            workspace::WorkspaceMatching::None
+        );
+        assert!(!options.add_dirs_to_sidebar);
+        assert!(options.requesting_window.is_none());
+    }
+
     #[gpui::test]
     fn test_parse_agent_url(cx: &mut TestAppContext) {
         let _app_state = init_test(cx);
@@ -2166,6 +2227,25 @@ mod tests {
         }
     }
 
+    fn make_cli_url_open_request(
+        urls: Vec<String>,
+        open_behavior: cli::OpenBehavior,
+    ) -> CliRequest {
+        CliRequest::Open {
+            paths: vec![],
+            urls,
+            diff_paths: vec![],
+            diff_all: false,
+            wsl: None,
+            wait: false,
+            open_behavior,
+            env: None,
+            user_data_dir: None,
+            dev_container: false,
+            cwd: None,
+        }
+    }
+
     /// Runs the real [`cli::run_cli_response_loop`] on an OS thread against
     /// the Zed-side `handle_cli_connection` on the GPUI foreground executor,
     /// using `allow_parking` so the test scheduler tolerates cross-thread
@@ -2472,6 +2552,35 @@ mod tests {
         assert_eq!(cx.windows().len(), 2);
     }
 
+    #[gpui::test]
+    async fn test_e2e_explicit_new_flag_with_file_url_opens_new_window(cx: &mut TestAppContext) {
+        let app_state = init_test(cx);
+
+        app_state
+            .fs
+            .as_fake()
+            .insert_tree(path!("/project"), json!({ "file.txt": "content" }))
+            .await;
+
+        open_workspace_file(path!("/project"), Default::default(), app_state.clone(), cx).await;
+        assert_eq!(cx.windows().len(), 1);
+
+        let file_url = format!(
+            "file://{}",
+            urlencoding::encode(path!("/project/file.txt")).into_owned()
+        );
+        let (status, prompt_shown) = run_cli_with_zed_handler(
+            cx,
+            app_state,
+            make_cli_url_open_request(vec![file_url], cli::OpenBehavior::AlwaysNew),
+            None,
+        );
+
+        assert_eq!(status, 0);
+        assert!(!prompt_shown, "no prompt should be shown with -n flag");
+        assert_eq!(cx.windows().len(), 2);
+    }
+
     #[gpui::test]
     async fn test_e2e_paths_in_existing_workspace_no_prompt(cx: &mut TestAppContext) {
         let app_state = init_test(cx);

From 5656f3eb3f431c195f721cb3cfbcb9d73f5aed0f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=20Houl=C3=A9?=
 <13155277+tomhoule@users.noreply.github.com>
Date: Wed, 20 May 2026 09:00:02 +0200
Subject: [PATCH 055/105] client: Use cloud as source of truth for the selected
 organization (#57140)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Now that the cloud platform exposes a system-settings endpoint for the
user's selected organization, switch `UserStore` over to it and drop the
local database persistence. The server already returns the current
selected organization for `get_authenticated_user()`.

set_current_organization becomes a optimistic, with the in-memory
selection updated immediately. hen a background task POSTs to the system
settings endpoint.

Stale current_organization_id rows from older installs are left dangling
— harmless and not worth a migration. This is the second step in moving
organization selection to cloud; the first added the
update_system_settings client method.

Part of CLO-716

Release Notes:

- N/A

---------

Co-authored-by: Marshall Bowers <git@maxdeviant.com>
---
 Cargo.lock                        |  1 -
 crates/client/Cargo.toml          |  1 -
 crates/client/src/user.rs         | 71 ++++++++++++++++---------------
 crates/title_bar/src/title_bar.rs | 13 ++++--
 4 files changed, 45 insertions(+), 41 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 877ae7160ff..bfecd88f452 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3006,7 +3006,6 @@ dependencies = [
  "cloud_llm_client",
  "collections",
  "credentials_provider",
- "db",
  "derive_more",
  "feature_flags",
  "fs",
diff --git a/crates/client/Cargo.toml b/crates/client/Cargo.toml
index 0a3c49d1237..91c35a15bb6 100644
--- a/crates/client/Cargo.toml
+++ b/crates/client/Cargo.toml
@@ -27,7 +27,6 @@ cloud_api_types.workspace = true
 cloud_llm_client.workspace = true
 collections.workspace = true
 credentials_provider.workspace = true
-db.workspace = true
 derive_more.workspace = true
 feature_flags.workspace = true
 fs.workspace = true
diff --git a/crates/client/src/user.rs b/crates/client/src/user.rs
index 6d3f0efe85e..c05518cdbac 100644
--- a/crates/client/src/user.rs
+++ b/crates/client/src/user.rs
@@ -4,19 +4,19 @@ use chrono::{DateTime, Utc};
 use cloud_api_client::websocket_protocol::MessageToClient;
 use cloud_api_client::{
     GetAuthenticatedUserResponse, KnownOrUnknown, Organization, OrganizationId, Plan, PlanInfo,
+    UpdateSystemSettingsBody,
 };
 use cloud_api_types::OrganizationConfiguration;
 use cloud_llm_client::{
     EDIT_PREDICTIONS_USAGE_AMOUNT_HEADER_NAME, EDIT_PREDICTIONS_USAGE_LIMIT_HEADER_NAME, UsageLimit,
 };
 use collections::{HashMap, HashSet, hash_map::Entry};
-use db::kvp::KeyValueStore;
 use derive_more::Deref;
 use feature_flags::FeatureFlagAppExt;
 use futures::{Future, StreamExt, channel::mpsc};
 use gpui::{
-    App, AsyncApp, Context, Entity, EventEmitter, SharedString, SharedUri, Task, TaskExt,
-    WeakEntity,
+    App, AppContext as _, AsyncApp, Context, Entity, EventEmitter, SharedString, SharedUri, Task,
+    TaskExt, WeakEntity,
 };
 use http_client::http::{HeaderMap, HeaderValue};
 use postage::{sink::Sink, watch};
@@ -28,8 +28,6 @@ use std::{
 use text::ReplicaId;
 use util::{ResultExt, TryFutureExt as _};
 
-const CURRENT_ORGANIZATION_ID_KEY: &str = "current_organization_id";
-
 pub type LegacyUserId = u64;
 
 #[derive(
@@ -708,24 +706,41 @@ impl UserStore {
         &mut self,
         organization: Arc<Organization>,
         cx: &mut Context<Self>,
-    ) {
+    ) -> Task<Result<()>> {
         let is_same_organization = self
             .current_organization
             .as_ref()
             .is_some_and(|current| current.id == organization.id);
 
-        if !is_same_organization {
-            let organization_id = organization.id.0.to_string();
-            self.current_organization.replace(organization);
-            cx.emit(Event::OrganizationChanged);
-            cx.notify();
-
-            let kvp = KeyValueStore::global(cx);
-            db::write_and_log(cx, move || async move {
-                kvp.write_kvp(CURRENT_ORGANIZATION_ID_KEY.into(), organization_id)
-                    .await
-            });
+        if is_same_organization {
+            return Task::ready(Ok(()));
         }
+
+        let organization_id = organization.id.clone();
+        self.current_organization.replace(organization);
+        cx.emit(Event::OrganizationChanged);
+        cx.notify();
+
+        let Some(client) = self.client.upgrade() else {
+            return Task::ready(Ok(()));
+        };
+        let Some(system_id) = client.telemetry().system_id().map(|id| id.to_string()) else {
+            // Without a system ID we have no addressable target row on the
+            // server, so the selection stays purely session-local.
+            return Task::ready(Ok(()));
+        };
+        let cloud_client = client.cloud_client();
+
+        cx.background_spawn(async move {
+            let body = UpdateSystemSettingsBody {
+                selected_organization_id: Some(organization_id),
+            };
+            cloud_client
+                .update_system_settings(system_id, body)
+                .await
+                .context("failed to persist selected organization")?;
+            Ok(())
+        })
     }
 
     pub fn organizations(&self) -> &Vec<Arc<Organization>> {
@@ -861,29 +876,15 @@ impl UserStore {
         }
 
         self.organizations = response.organizations.into_iter().map(Arc::new).collect();
-        let persisted_org_id = KeyValueStore::global(cx)
-            .read_kvp(CURRENT_ORGANIZATION_ID_KEY)
-            .log_err()
-            .flatten()
-            .map(|id| OrganizationId(Arc::from(id)));
 
-        self.current_organization = persisted_org_id
-            .and_then(|persisted_id| {
+        self.current_organization = response
+            .default_organization_id
+            .and_then(|default_organization_id| {
                 self.organizations
                     .iter()
-                    .find(|org| org.id == persisted_id)
+                    .find(|organization| organization.id == default_organization_id)
                     .cloned()
             })
-            .or_else(|| {
-                response
-                    .default_organization_id
-                    .and_then(|default_organization_id| {
-                        self.organizations
-                            .iter()
-                            .find(|organization| organization.id == default_organization_id)
-                            .cloned()
-                    })
-            })
             .or_else(|| self.organizations.first().cloned());
         self.plans_by_organization = response
             .plans_by_organization
diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs
index 62d11beec30..b2f2b4f436d 100644
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -51,7 +51,8 @@ use ui::{
 use update_version::UpdateVersion;
 use util::ResultExt;
 use workspace::{
-    MultiWorkspace, ToggleWorktreeSecurity, Workspace, notifications::NotifyResultExt,
+    MultiWorkspace, ToggleWorktreeSecurity, Workspace,
+    notifications::{NotifyResultExt, NotifyTaskExt as _},
 };
 
 use zed_actions::OpenRemote;
@@ -1159,6 +1160,7 @@ impl TitleBar {
         let show_update_button = self.update_version.read(cx).show_update_in_menu_bar();
 
         let user_store = self.user_store.clone();
+        let workspace = self.workspace.clone();
         let user_store_read = user_store.read(cx);
         let user = user_store_read.current_user();
 
@@ -1225,6 +1227,7 @@ impl TitleBar {
                 let current_organization = current_organization.clone();
                 let organizations = organizations.clone();
                 let user_store = user_store.clone();
+                let workspace = workspace.clone();
 
                 let ai_enabled = !project::DisableAiSettings::get_global(cx).disable_ai;
                 let current_layout = AgentSettings::get_layout(cx);
@@ -1316,11 +1319,13 @@ impl TitleBar {
                                 {
                                     let user_store = user_store.clone();
                                     let organization = organization.clone();
-                                    move |_window, cx| {
-                                        user_store.update(cx, |user_store, cx| {
+                                    let workspace = workspace.clone();
+                                    move |window, cx| {
+                                        let task = user_store.update(cx, |user_store, cx| {
                                             user_store
-                                                .set_current_organization(organization.clone(), cx);
+                                                .set_current_organization(organization.clone(), cx)
                                         });
+                                        task.detach_and_notify_err(workspace.clone(), window, cx);
                                     }
                                 },
                             );

From 80d41375e5562bea8ae338cd274e02f4fdb22b23 Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Wed, 20 May 2026 10:36:32 +0200
Subject: [PATCH 056/105] agent: Save files when model uses rename tool
 (#57228)

Release Notes:

- N/A
---
 crates/agent/src/tools/rename_tool.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/crates/agent/src/tools/rename_tool.rs b/crates/agent/src/tools/rename_tool.rs
index ac8fa1dccb2..d05b9872b8c 100644
--- a/crates/agent/src/tools/rename_tool.rs
+++ b/crates/agent/src/tools/rename_tool.rs
@@ -2,6 +2,7 @@ use std::fmt::Write;
 use std::sync::Arc;
 
 use agent_client_protocol::schema as acp;
+use collections::HashSet;
 use gpui::{App, Entity, SharedString, Task};
 use project::Project;
 use schemars::JsonSchema;
@@ -95,6 +96,12 @@ impl AgentTool for RenameTool {
                 ));
             }
 
+            let buffers = transaction.0.keys().cloned().collect::<HashSet<_>>();
+            project
+                .update(cx, |project, cx| project.save_buffers(buffers, cx))
+                .await
+                .map_err(|e| format!("Rename succeeded, but failed to save renamed files: {e}"))?;
+
             let mut output = format!(
                 "Renamed `{}` to `{}` in {} file(s):\n",
                 input.symbol.symbol_name,

From e82c04b356468416c40f38d5909123e3af596f93 Mon Sep 17 00:00:00 2001
From: Cameron Mcloughlin <cameron.studdstreet@gmail.com>
Date: Wed, 20 May 2026 09:57:46 +0100
Subject: [PATCH 057/105] agent: Pull diagnostics (#56663)

Currently, the `diagnostics` tool queries the current state of the
workspace. However, if the LSP is slow to update diagnostics, this can
lead to stale diagnostics being given to the agent.

This PR changes the `diagnostics` tool to attempt to pull fresh
diagnostics. If it fails, it informs the agent and falls back to the old
behaviour (not all LSPs support pull-based diagnostics).

Release Notes:

- N/A or Added/Fixed/Improved ...
---
 crates/agent/src/tools/diagnostics_tool.rs | 117 +++++++++++++++++----
 crates/project/src/lsp_store.rs            |  51 ++++++++-
 2 files changed, 145 insertions(+), 23 deletions(-)

diff --git a/crates/agent/src/tools/diagnostics_tool.rs b/crates/agent/src/tools/diagnostics_tool.rs
index 1d6528007d0..89d4ef54677 100644
--- a/crates/agent/src/tools/diagnostics_tool.rs
+++ b/crates/agent/src/tools/diagnostics_tool.rs
@@ -1,16 +1,18 @@
 use crate::{AgentTool, ToolCallEventStream, ToolInput};
 use agent_client_protocol::schema as acp;
-use anyhow::Result;
-use futures::FutureExt as _;
-use gpui::{App, Entity, Task};
+use futures::{Future, FutureExt as _};
+use gpui::{App, AsyncApp, Entity, Task};
 use language::{DiagnosticSeverity, OffsetRangeExt};
 use project::Project;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
+use std::path::Path;
 use std::{fmt::Write, sync::Arc};
 use ui::SharedString;
 use util::markdown::MarkdownInlineCode;
 
+type Result<T, E = String> = core::result::Result<T, E>;
+
 /// Get errors and warnings for the project or a specific file.
 ///
 /// This tool can be invoked after a series of edits to determine if further edits are necessary, or if the user asks to fix errors or warnings in their codebase.
@@ -18,6 +20,11 @@ use util::markdown::MarkdownInlineCode;
 /// When a path is provided, shows all diagnostics for that specific file.
 /// When no path is provided, shows a summary of error and warning counts for all files in the project.
 ///
+/// This tool attempts to refresh diagnostics before returning.
+/// If refreshing diagnostics fails (for example, if the language server does not support pull-based diagnostics), it will return any diagnostics already present.
+/// Note that, in this case, the results may be out-of-date, and may or may not reflect the most recent edits.
+/// If this happens, do not attempt to re-run this tool in the hope that refreshing will later succeed. Failures are typically persistent.
+///
 /// <example>
 /// To get diagnostics for a specific file:
 /// {
@@ -60,6 +67,71 @@ impl DiagnosticsTool {
     }
 }
 
+async fn with_cancellation<T>(f: impl Future<Output = T>, s: &ToolCallEventStream) -> Result<T> {
+    futures::select! {
+        result = f.fuse() => Ok(result),
+        _ = s.cancelled_by_user().fuse() => {
+            Err("Diagnostics cancelled by user".to_string())
+        }
+    }
+}
+
+fn freshness_message(refreshed: bool) -> &'static str {
+    if refreshed {
+        "Diagnostics successfully refreshed."
+    } else {
+        "Failed to refresh diagnostics. Diagnostics may be stale."
+    }
+}
+
+/// Attempt to pull fresh diagnostics from the LSP before reading them.
+///
+/// Returns `Ok(true)` if diagnostics were successfully refreshed,
+/// `Ok(false)` if the pull failed (callers should fall through to
+/// read cached diagnostics), or `Err` if cancelled by the user.
+async fn pull_diagnostics(
+    project: &Entity<Project>,
+    path: Option<&Path>,
+    event_stream: &ToolCallEventStream,
+    cx: &mut AsyncApp,
+) -> Result<bool, String> {
+    match path {
+        Some(path) => {
+            let open_buffer_task = project.update(cx, |project, cx| {
+                let Some(project_path) = project.find_project_path(path, cx) else {
+                    return Err(format!("Could not find path {} in project", path.display()));
+                };
+                Ok(project.open_buffer(project_path, cx))
+            })?;
+
+            let buffer = with_cancellation(open_buffer_task, event_stream)
+                .await?
+                .map_err(|e| e.to_string())?;
+
+            let lsp_store = project.read_with(cx, |project, _cx| project.lsp_store());
+            let pull_task = lsp_store.update(cx, |lsp_store, cx| {
+                lsp_store.pull_diagnostics_for_buffer(buffer, cx)
+            });
+            let pull_result = with_cancellation(pull_task, event_stream).await?;
+            if let Err(error) = &pull_result {
+                log::warn!("Failed to pull diagnostics, using cached: {error:#}");
+            }
+            Ok(pull_result.is_ok())
+        }
+        None => {
+            let lsp_store = project.read_with(cx, |project, _cx| project.lsp_store());
+            let pull_task = lsp_store.update(cx, |lsp_store, cx| {
+                lsp_store.pull_workspace_diagnostics_once(cx)
+            });
+            let succeeded = with_cancellation(pull_task, event_stream).await?;
+            if !succeeded {
+                log::warn!("Failed to pull workspace diagnostics, using cached");
+            }
+            Ok(succeeded)
+        }
+    }
+}
+
 impl AgentTool for DiagnosticsTool {
     type Input = DiagnosticsToolInput;
     type Output = String;
@@ -96,21 +168,22 @@ impl AgentTool for DiagnosticsTool {
             let input = input.recv().await.map_err(|e| e.to_string())?;
 
             match input.path {
-                Some(path) if !path.is_empty() => {
-                    let (_project_path, open_buffer_task) = project.update(cx, |project, cx| {
-                        let Some(project_path) = project.find_project_path(&path, cx) else {
+                Some(ref path) if !path.is_empty() => {
+                    let refreshed =
+                        pull_diagnostics(&project, Some(Path::new(path)), &event_stream, cx)
+                            .await?;
+
+                    let open_buffer_task = project.update(cx, |project, cx| {
+                        let Some(project_path) = project.find_project_path(path, cx) else {
                             return Err(format!("Could not find path {path} in project"));
                         };
-                        let task = project.open_buffer(project_path.clone(), cx);
-                        Ok((project_path, task))
+                        Ok(project.open_buffer(project_path, cx))
                     })?;
 
-                    let buffer = futures::select! {
-                        result = open_buffer_task.fuse() => result.map_err(|e| e.to_string())?,
-                        _ = event_stream.cancelled_by_user().fuse() => {
-                            return Err("Diagnostics cancelled by user".to_string());
-                        }
-                    };
+                    let buffer = with_cancellation(open_buffer_task, &event_stream)
+                        .await?
+                        .map_err(|e| e.to_string())?;
+
                     let mut output = String::new();
                     let snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot());
 
@@ -133,13 +206,18 @@ impl AgentTool for DiagnosticsTool {
                         .ok();
                     }
 
+                    let freshness = freshness_message(refreshed);
                     if output.is_empty() {
-                        Ok("File doesn't have errors or warnings!".to_string())
+                        Ok(format!(
+                            "{freshness}\n\nFile doesn't have errors or warnings!"
+                        ))
                     } else {
-                        Ok(output)
+                        Ok(format!("{freshness}\n\n{output}"))
                     }
                 }
                 _ => {
+                    let refreshed = pull_diagnostics(&project, None, &event_stream, cx).await?;
+
                     let (output, has_diagnostics) = project.read_with(cx, |project, cx| {
                         let mut output = String::new();
                         let mut has_diagnostics = false;
@@ -165,10 +243,13 @@ impl AgentTool for DiagnosticsTool {
                         (output, has_diagnostics)
                     });
 
+                    let freshness = freshness_message(refreshed);
                     if has_diagnostics {
-                        Ok(output)
+                        Ok(format!("{freshness}\n\n{output}"))
                     } else {
-                        Ok("No errors or warnings found in the project.".into())
+                        Ok(format!(
+                            "{freshness}\n\nNo errors or warnings found in the project."
+                        ))
                     }
                 }
             }
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index c943498817d..fd738b0f7ad 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -58,6 +58,7 @@ use clock::Global;
 use collections::{BTreeMap, BTreeSet, HashMap, HashSet, btree_map};
 use futures::{
     AsyncWriteExt, Future, FutureExt, StreamExt,
+    channel::oneshot,
     future::{Either, Shared, join_all, pending, select},
     select, select_biased,
     stream::FuturesUnordered,
@@ -12423,11 +12424,45 @@ impl LspStore {
             .and_then(|local| local.language_servers.get_mut(&server_id))
         {
             for diagnostics in workspace_diagnostics_refresh_tasks.values_mut() {
-                diagnostics.refresh_tx.try_send(()).ok();
+                diagnostics.refresh_tx.try_send(None).ok();
             }
         }
     }
 
+    /// Triggers a workspace diagnostics pull on all running language servers
+    /// and returns a [`Task`] that resolves once the requests have completed.
+    ///
+    /// This reuses the same background refresh loops as
+    /// [`Self::pull_workspace_diagnostics`], but provides a completion signal
+    /// so callers can wait for fresh diagnostics before reading them.
+    pub fn pull_workspace_diagnostics_once(&mut self, cx: &mut Context<Self>) -> Task<bool> {
+        let Some(local) = self.as_local_mut() else {
+            return Task::ready(true);
+        };
+
+        let mut receivers = Vec::new();
+        for state in local.language_servers.values_mut() {
+            let LanguageServerState::Running {
+                workspace_diagnostics_refresh_tasks,
+                ..
+            } = state
+            else {
+                continue;
+            };
+            for task in workspace_diagnostics_refresh_tasks.values_mut() {
+                let (tx, rx) = oneshot::channel();
+                task.refresh_tx.try_send(Some(tx)).ok();
+                receivers.push(rx);
+            }
+        }
+
+        cx.background_spawn(async {
+            FuturesUnordered::from_iter(receivers)
+                .all(async |result| result.unwrap_or(false))
+                .await
+        })
+    }
+
     /// Refreshes `textDocument/diagnostic` for all open buffers associated with the given server.
     /// This is called in response to `workspace/diagnostic/refresh` to comply with the LSP spec,
     /// which requires refreshing both workspace and document diagnostics.
@@ -13517,8 +13552,8 @@ fn lsp_workspace_diagnostics_refresh(
     let registration_id_shared = registration_id.as_ref().map(SharedString::from);
 
     let (progress_tx, mut progress_rx) = mpsc::channel(1);
-    let (mut refresh_tx, mut refresh_rx) = mpsc::channel(1);
-    refresh_tx.try_send(()).ok();
+    let (mut refresh_tx, mut refresh_rx) = mpsc::channel::<Option<oneshot::Sender<bool>>>(1);
+    refresh_tx.try_send(None).ok();
 
     let request_timeout = ProjectSettings::get_global(cx)
         .global_lsp_settings
@@ -13538,7 +13573,7 @@ fn lsp_workspace_diagnostics_refresh(
         let mut requests = 0;
 
         loop {
-            let Some(()) = refresh_rx.recv().await else {
+            let Some(mut completion_tx) = refresh_rx.recv().await else {
                 return;
             };
 
@@ -13614,6 +13649,9 @@ fn lsp_workspace_diagnostics_refresh(
                     }
                     ConnectionResult::Result(Err(e)) => {
                         log::error!("Error during workspace diagnostics pull: {e:#}");
+                        if let Some(tx) = completion_tx.take() {
+                            tx.send(false).ok();
+                        }
                         break 'request;
                     }
                     ConnectionResult::Result(Ok(pulled_diagnostics)) => {
@@ -13631,6 +13669,9 @@ fn lsp_workspace_diagnostics_refresh(
                         {
                             return;
                         }
+                        if let Some(tx) = completion_tx.take() {
+                            tx.send(true).ok();
+                        }
                         break 'request;
                     }
                 }
@@ -14109,7 +14150,7 @@ impl LanguageServerLogType {
 }
 
 pub struct WorkspaceRefreshTask {
-    refresh_tx: mpsc::Sender<()>,
+    refresh_tx: mpsc::Sender<Option<oneshot::Sender<bool>>>,
     progress_tx: mpsc::Sender<()>,
     #[allow(dead_code)]
     task: Task<()>,

From bc363322afe554a6fe54c9f12fead888d663c694 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <git@maxdeviant.com>
Date: Wed, 20 May 2026 06:46:54 -0400
Subject: [PATCH 058/105] Upgrade `tree-sitter` to v0.26.9 (#57183)

This PR upgrades `tree-sitter` to v0.26.9.

We're interested in
https://github.com/tree-sitter/tree-sitter/pull/5605, which should fix a
panic when loading certain grammars.

Closes FR-1.

Release Notes:

- Fixed a panic when loading certain Tree-sitter grammars containing
supertypes.
---
 Cargo.lock | 12 ++++++------
 Cargo.toml |  2 +-
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index bfecd88f452..60b7b291ae5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -18793,9 +18793,9 @@ dependencies = [
 
 [[package]]
 name = "tree-sitter"
-version = "0.26.8"
+version = "0.26.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "887bd495d0582c5e3e0d8ece2233666169fa56a9644d172fc22ad179ab2d0538"
+checksum = "4dab76d0b724ba557954125188cf0633a1ca43199ced82d95c7b9c32cc3de1f3"
 dependencies = [
  "cc",
  "regex",
@@ -20080,9 +20080,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-c-api-impl"
-version = "36.0.6"
+version = "36.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3c62ea3fa30e6b0cf61116b3035121b8f515c60ac118ebfdab2ee56d028ed1e"
+checksum = "e5e71e971a27df819171b79597c0f1826fc7cf2c168111c64dbc5505a1ffbda7"
 dependencies = [
  "anyhow",
  "log",
@@ -20129,9 +20129,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-internal-c-api-macros"
-version = "36.0.6"
+version = "36.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c8c61294155a6d23c202f08cf7a2f9392a866edd50517508208818be626ce9f"
+checksum = "20b9553165039d365931a998d9b60278cc968ba9d81531cecde8ffc3effa1fe3"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 619cc83a084..e936bea3d71 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -764,7 +764,7 @@ toml_edit = { version = "0.22", default-features = false, features = [
     "serde",
 ] }
 tower-http = "0.4.4"
-tree-sitter = { version = "0.26.8", features = ["wasm"] }
+tree-sitter = { version = "0.26.9", features = ["wasm"] }
 tree-sitter-bash = "0.25.1"
 tree-sitter-c = "0.24.1"
 tree-sitter-cpp = { git = "https://github.com/tree-sitter/tree-sitter-cpp", rev = "5cb9b693cfd7bfacab1d9ff4acac1a4150700609" }

From d33a3186aab63ac3b57c9cbe1da7b482d42c2fc5 Mon Sep 17 00:00:00 2001
From: Oleksiy Syvokon <oleksiy@zed.dev>
Date: Wed, 20 May 2026 15:41:02 +0300
Subject: [PATCH 059/105] Respect max line limit for invisible character
 replacements (#57137)

This change makes sure that `LineWithInvisibles::from_chunks` applies
the max line length limit to invisible character replacements as it does
to normal text chunks.

Without this change, pathological lines containing many invisible
characters could produce unbounded number of line fragments.

Closes FR-6.

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable


Release Notes:

- Fixed a rare panic that could occur when lines in the editor contained
many invisible characters.
---
 crates/editor/src/element.rs | 79 +++++++++++++++++++++++++++++++++++-
 1 file changed, 77 insertions(+), 2 deletions(-)

diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index 97380794178..7e03201b278 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -9001,6 +9001,15 @@ impl LineWithInvisibles {
             replacement: None,
         }]) {
             if let Some(replacement) = highlighted_chunk.replacement {
+                if line_exceeded_max_len {
+                    continue;
+                }
+
+                if len + line.len() + highlighted_chunk.text.len() > max_line_len {
+                    line_exceeded_max_len = true;
+                    continue;
+                }
+
                 if !line.is_empty() {
                     let segments = bg_segments_per_row.get(row).map(|v| &v[..]).unwrap_or(&[]);
                     let text_runs: &[TextRun] = if segments.is_empty() {
@@ -9132,8 +9141,9 @@ impl LineWithInvisibles {
                             Cow::Borrowed(text_style)
                         };
 
-                        if line.len() + line_chunk.len() > max_line_len {
-                            let mut chunk_len = max_line_len - line.len();
+                        let current_line_len = len + line.len();
+                        if current_line_len + line_chunk.len() > max_line_len {
+                            let mut chunk_len = max_line_len - current_line_len;
                             while !line_chunk.is_char_boundary(chunk_len) {
                                 chunk_len -= 1;
                             }
@@ -9141,6 +9151,10 @@ impl LineWithInvisibles {
                             line_exceeded_max_len = true;
                         }
 
+                        if line_chunk.is_empty() {
+                            continue;
+                        }
+
                         styles.push(TextRun {
                             len: line_chunk.len(),
                             font: text_style.font(),
@@ -13573,6 +13587,67 @@ mod tests {
         );
     }
 
+    #[gpui::test]
+    fn test_replacement_chunks_are_clipped_to_max_line_len(cx: &mut TestAppContext) {
+        init_test(cx, |_| {});
+
+        let window = cx.add_window(|window, cx| {
+            let buffer = MultiBuffer::build_simple("", cx);
+            Editor::new(EditorMode::full(), buffer, None, window, cx)
+        });
+        let cx = &mut VisualTestContext::from_window(*window, cx);
+        let editor = window.root(cx).unwrap();
+        let style = cx.update(|_, cx| editor.update(cx, |editor, cx| editor.style(cx).clone()));
+        let editor_mode = EditorMode::full();
+        let max_line_len = "\u{00a0}abcdef".len();
+
+        window
+            .update(cx, |_, window, cx| {
+                let chunks = std::iter::once(HighlightedChunk {
+                    text: "\u{00a0}",
+                    style: None,
+                    is_tab: false,
+                    is_inlay: false,
+                    replacement: Some(ChunkReplacement::Str("\u{2007}".into())),
+                })
+                .chain(std::iter::once(HighlightedChunk {
+                    text: "abcdefghi",
+                    style: None,
+                    is_tab: false,
+                    is_inlay: false,
+                    replacement: None,
+                }))
+                .chain(
+                    std::iter::repeat_with(|| HighlightedChunk {
+                        text: "\u{00a0}",
+                        style: None,
+                        is_tab: false,
+                        is_inlay: false,
+                        replacement: Some(ChunkReplacement::Str("\u{2007}".into())),
+                    })
+                    .take(8),
+                );
+
+                let layouts = LineWithInvisibles::from_chunks(
+                    chunks,
+                    &style,
+                    max_line_len,
+                    1,
+                    &editor_mode,
+                    px(500.),
+                    |_| false,
+                    &[],
+                    window,
+                    cx,
+                );
+
+                assert_eq!(layouts.len(), 1);
+                assert_eq!(layouts[0].len, max_line_len);
+                assert!(layouts[0].fragments.len() <= max_line_len);
+            })
+            .unwrap();
+    }
+
     #[gpui::test]
     fn test_invisibles_dont_appear_in_certain_editors(cx: &mut TestAppContext) {
         init_test(cx, |s| {

From 1103bd80556dc77ee7cfdeed8504ac30c923865b Mon Sep 17 00:00:00 2001
From: Ben Brandt <benjamin.j.brandt@gmail.com>
Date: Wed, 20 May 2026 14:47:18 +0200
Subject: [PATCH 060/105] agent_ui: Improve agent terminal notification
 visibility logic (#57248)

Aligns Terminal notifications much closer to Thread notifications

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Release Notes:

- N/A
---
 crates/agent_ui/src/agent_panel.rs       | 669 ++++++++++++++++++++++-
 crates/agent_ui/src/conversation_view.rs | 111 +++-
 crates/agent_ui/src/test_support.rs      |  71 ++-
 3 files changed, 810 insertions(+), 41 deletions(-)

diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs
index c7a962b277d..cd3f7ae2264 100644
--- a/crates/agent_ui/src/agent_panel.rs
+++ b/crates/agent_ui/src/agent_panel.rs
@@ -1275,6 +1275,11 @@ impl AgentPanel {
             },
         );
 
+        cx.on_release(|this, cx| {
+            this.dismiss_all_terminal_notifications(cx);
+        })
+        .detach();
+
         let mut panel = Self {
             workspace_id,
             base_view,
@@ -2217,16 +2222,7 @@ impl AgentPanel {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        let is_active = self.active_terminal_id() == Some(terminal_id);
-        // Only suppress when the user can actually see the bell, i.e. the
-        // terminal is focused AND the OS window is active. A bell delivered to
-        // a background window should still be marked unseen.
-        let user_is_looking = is_active
-            && window.is_window_active()
-            && self.terminals.get(&terminal_id).is_some_and(|terminal| {
-                terminal.view.focus_handle(cx).contains_focused(window, cx)
-            });
-        if user_is_looking {
+        if self.active_terminal_visible(terminal_id, window, cx) {
             return;
         }
         let newly_notified = {
@@ -2244,7 +2240,10 @@ impl AgentPanel {
             cx.emit(AgentPanelEvent::EntryChanged);
             cx.notify();
             #[cfg(feature = "audio")]
-            self.play_terminal_notification_sound(cx);
+            self.play_terminal_notification_sound(
+                self.terminal_status_visible(terminal_id, window, cx),
+                cx,
+            );
             self.show_terminal_notification(terminal_id, window, cx);
         }
     }
@@ -2262,6 +2261,9 @@ impl AgentPanel {
             return;
         }
         let title = terminal.title(cx);
+        if self.terminal_status_visible(terminal_id, window, cx) {
+            return;
+        }
         let settings = AgentSettings::get_global(cx);
         match settings.notify_when_agent_waiting {
             NotifyWhenAgentWaiting::PrimaryScreen => {
@@ -2338,6 +2340,8 @@ impl AgentPanel {
                             })
                             .log_err();
                     });
+
+                    this.dismiss_terminal_notifications(terminal_id, cx);
                 }
                 AgentNotificationEvent::Dismissed => {
                     this.dismiss_terminal_notifications(terminal_id, cx);
@@ -2353,10 +2357,25 @@ impl AgentPanel {
             }
         });
 
-        let multi_workspace_subscription = window.root::<MultiWorkspace>().flatten().map(|mw| {
-            cx.observe_in(&mw, window, move |this, _, window, cx| {
-                this.dismiss_terminal_pop_up_if_visible(terminal_id, &pop_up_weak, window, cx);
+        let multi_workspace_subscription = {
+            let pop_up_weak = pop_up_weak.clone();
+            window.root::<MultiWorkspace>().flatten().map(|mw| {
+                cx.observe_in(&mw, window, move |this, _, window, cx| {
+                    this.dismiss_terminal_pop_up_if_visible(terminal_id, &pop_up_weak, window, cx);
+                })
             })
+        };
+
+        let this_panel = cx.entity();
+        let agent_panel_subscription = cx.subscribe_in(&this_panel, window, {
+            move |this, _, event: &AgentPanelEvent, window, cx| match event {
+                AgentPanelEvent::ActiveViewChanged | AgentPanelEvent::ActiveViewFocused => {
+                    this.dismiss_terminal_pop_up_if_visible(terminal_id, &pop_up_weak, window, cx);
+                }
+                AgentPanelEvent::EntryChanged
+                | AgentPanelEvent::TerminalClosed { .. }
+                | AgentPanelEvent::ThreadInteracted { .. } => {}
+            }
         });
 
         let Some(terminal) = self.terminals.get_mut(&terminal_id) else {
@@ -2370,12 +2389,15 @@ impl AgentPanel {
         terminal
             .notification_subscriptions
             .push(window_activation_subscription);
+        terminal
+            .notification_subscriptions
+            .push(agent_panel_subscription);
         if let Some(subscription) = multi_workspace_subscription {
             terminal.notification_subscriptions.push(subscription);
         }
     }
 
-    fn dismiss_terminal_notifications(&mut self, terminal_id: TerminalId, cx: &mut Context<Self>) {
+    fn dismiss_terminal_notifications(&mut self, terminal_id: TerminalId, cx: &mut App) {
         let Some(terminal) = self.terminals.get_mut(&terminal_id) else {
             return;
         };
@@ -2390,11 +2412,18 @@ impl AgentPanel {
         }
     }
 
-    fn terminal_visible_to_user(&self, terminal_id: TerminalId, window: &Window, cx: &App) -> bool {
+    fn dismiss_all_terminal_notifications(&mut self, cx: &mut App) {
+        let terminal_ids = self.terminals.keys().copied().collect::<Vec<_>>();
+        for terminal_id in terminal_ids {
+            self.dismiss_terminal_notifications(terminal_id, cx);
+        }
+    }
+
+    fn active_terminal_visible(&self, terminal_id: TerminalId, window: &Window, cx: &App) -> bool {
         if !window.is_window_active() {
             return false;
         }
-        if self.active_terminal_id() != Some(terminal_id) {
+        if !self.terminal_surface_visible(terminal_id) {
             return false;
         }
         let Some(workspace) = self.workspace.upgrade() else {
@@ -2402,9 +2431,6 @@ impl AgentPanel {
         };
         if let Some(multi_workspace) = window.root::<MultiWorkspace>().flatten() {
             let multi_workspace = multi_workspace.read(cx);
-            if multi_workspace.sidebar_open() {
-                return true;
-            }
             if multi_workspace.workspace() != &workspace {
                 return false;
             }
@@ -2412,6 +2438,36 @@ impl AgentPanel {
         AgentPanel::is_visible(&workspace, cx)
     }
 
+    fn terminal_surface_visible(&self, terminal_id: TerminalId) -> bool {
+        self.active_terminal_id() == Some(terminal_id)
+            && matches!(self.visible_surface(), VisibleSurface::Terminal(_))
+    }
+
+    fn terminal_status_visible(&self, terminal_id: TerminalId, window: &Window, cx: &App) -> bool {
+        if !window.is_window_active() {
+            return false;
+        }
+
+        if let Some(multi_workspace) = window.root::<MultiWorkspace>().flatten() {
+            let multi_workspace = multi_workspace.read(cx);
+            if multi_workspace.sidebar_open() && multi_workspace.is_threads_list_view_active(cx) {
+                return true;
+            }
+
+            let Some(workspace) = self.workspace.upgrade() else {
+                return false;
+            };
+
+            return multi_workspace.workspace() == &workspace
+                && self.terminal_surface_visible(terminal_id)
+                && AgentPanel::is_visible(&workspace, cx);
+        }
+
+        self.workspace.upgrade().is_some_and(|workspace| {
+            self.terminal_surface_visible(terminal_id) && AgentPanel::is_visible(&workspace, cx)
+        })
+    }
+
     fn dismiss_terminal_pop_up_if_visible(
         &mut self,
         terminal_id: TerminalId,
@@ -2419,9 +2475,17 @@ impl AgentPanel {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        if !self.terminal_visible_to_user(terminal_id, window, cx) {
+        if !self.terminal_status_visible(terminal_id, window, cx) {
             return;
         }
+        if self.active_terminal_visible(terminal_id, window, cx)
+            && let Some(terminal) = self.terminals.get_mut(&terminal_id)
+            && terminal.has_notification
+        {
+            terminal.has_notification = false;
+            cx.emit(AgentPanelEvent::EntryChanged);
+            cx.notify();
+        }
         if let Some(pop_up) = pop_up.upgrade() {
             pop_up.update(cx, |notification, cx| {
                 notification.dismiss(cx);
@@ -2430,11 +2494,9 @@ impl AgentPanel {
     }
 
     #[cfg(feature = "audio")]
-    fn play_terminal_notification_sound(&self, cx: &mut App) {
-        // We only reach this when the user isn't looking at the terminal,
-        // so it is effectively hidden — only `Never` suppresses the sound.
+    fn play_terminal_notification_sound(&self, visible: bool, cx: &mut App) {
         let settings = AgentSettings::get_global(cx);
-        if settings.play_sound_when_agent_done.should_play(false) {
+        if settings.play_sound_when_agent_done.should_play(visible) {
             Audio::play_sound(Sound::AgentDone, cx);
         }
     }
@@ -3512,6 +3574,13 @@ impl AgentPanel {
         }
     }
 
+    pub(crate) fn visible_conversation_view(&self) -> Option<&Entity<ConversationView>> {
+        match self.visible_surface() {
+            VisibleSurface::AgentThread(conversation_view) => Some(conversation_view),
+            _ => None,
+        }
+    }
+
     pub fn conversation_views(&self) -> Vec<Entity<ConversationView>> {
         self.active_conversation_view()
             .into_iter()
@@ -5935,7 +6004,7 @@ mod tests {
     use crate::conversation_view::tests::{StubAgentServer, init_test};
     use crate::test_support::{
         active_session_id, active_thread_id, open_thread_with_connection,
-        open_thread_with_custom_connection, send_message,
+        open_thread_with_custom_connection, register_test_sidebar, send_message,
     };
     use acp_thread::{AgentConnection, StubAgentConnection, ThreadStatus, UserMessageId};
     use action_log::ActionLog;
@@ -7809,6 +7878,56 @@ mod tests {
         (panel, cx)
     }
 
+    async fn setup_visible_panel(
+        cx: &mut TestAppContext,
+    ) -> (Entity<AgentPanel>, VisualTestContext) {
+        setup_visible_panel_with_sidebar(cx, true).await
+    }
+
+    async fn setup_visible_panel_with_sidebar(
+        cx: &mut TestAppContext,
+        threads_list_active: bool,
+    ) -> (Entity<AgentPanel>, VisualTestContext) {
+        init_test(cx);
+        cx.update(|cx| {
+            agent::ThreadStore::init_global(cx);
+            language_model::LanguageModelRegistry::test(cx);
+            AgentSettings::override_global(
+                AgentSettings {
+                    notify_when_agent_waiting: NotifyWhenAgentWaiting::PrimaryScreen,
+                    ..AgentSettings::get_global(cx).clone()
+                },
+                cx,
+            );
+        });
+
+        let fs = FakeFs::new(cx.executor());
+        cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));
+        fs.insert_tree("/project", json!({ "file.txt": "" })).await;
+        let project = Project::test(fs.clone(), [Path::new("/project")], cx).await;
+
+        let multi_workspace =
+            cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
+
+        let workspace = multi_workspace
+            .read_with(cx, |multi_workspace, _cx| {
+                multi_workspace.workspace().clone()
+            })
+            .unwrap();
+
+        let mut cx = VisualTestContext::from_window(multi_workspace.into(), cx);
+        register_test_sidebar(threads_list_active, &mut cx);
+
+        let panel = workspace.update_in(&mut cx, |workspace, window, cx| {
+            let panel = cx.new(|cx| AgentPanel::new(workspace, None, window, cx));
+            workspace.add_panel(panel.clone(), window, cx);
+            workspace.focus_panel::<AgentPanel>(window, cx);
+            panel
+        });
+
+        (panel, cx)
+    }
+
     fn expected_terminal_drop_text(paths: &[PathBuf]) -> String {
         let mut text = String::new();
         for path in paths {
@@ -8578,6 +8697,499 @@ mod tests {
         });
     }
 
+    #[gpui::test]
+    async fn test_visible_terminal_bell_is_suppressed(cx: &mut TestAppContext) {
+        let (panel, mut cx) = setup_visible_panel(cx).await;
+        let terminal_id = panel
+            .update_in(&mut cx, |panel, window, cx| {
+                panel.insert_test_terminal("Claude", true, window, cx)
+            })
+            .expect("test terminal should be inserted");
+        cx.run_until_parked();
+
+        cx.update(|window, cx| {
+            assert!(window.is_window_active());
+            assert!(panel.read(cx).focus_handle(cx).contains_focused(window, cx));
+        });
+
+        panel.update(&mut cx, |panel, cx| {
+            panel.emit_test_terminal_bell(terminal_id, cx);
+        });
+        cx.run_until_parked();
+
+        panel.read_with(&cx, |panel, cx| {
+            let terminal = panel
+                .terminals(cx)
+                .into_iter()
+                .find(|terminal| terminal.id == terminal_id)
+                .expect("terminal should remain in the panel");
+            assert!(!terminal.has_notification);
+        });
+        assert!(
+            cx.windows()
+                .iter()
+                .all(|window| window.downcast::<AgentNotification>().is_none())
+        );
+    }
+
+    #[gpui::test]
+    async fn test_visible_terminal_bell_is_suppressed_without_focus(cx: &mut TestAppContext) {
+        let (panel, mut cx) = setup_visible_panel(cx).await;
+        let terminal_id = panel
+            .update_in(&mut cx, |panel, window, cx| {
+                panel.insert_test_terminal("Claude", true, window, cx)
+            })
+            .expect("test terminal should be inserted");
+        cx.run_until_parked();
+
+        let workspace = cx.update(|window, cx| {
+            window
+                .root::<MultiWorkspace>()
+                .flatten()
+                .expect("test window should have a MultiWorkspace root")
+                .read(cx)
+                .workspace()
+                .clone()
+        });
+        workspace.update_in(&mut cx, |workspace, window, cx| {
+            workspace.focus_handle(cx).focus(window, cx);
+        });
+        cx.update(|window, cx| {
+            assert!(window.is_window_active());
+            assert!(workspace.read(cx).focus_handle(cx).is_focused(window));
+            assert!(!panel.read(cx).focus_handle(cx).contains_focused(window, cx));
+        });
+
+        panel.update(&mut cx, |panel, cx| {
+            panel.emit_test_terminal_bell(terminal_id, cx);
+        });
+        cx.run_until_parked();
+
+        panel.read_with(&cx, |panel, cx| {
+            let terminal = panel
+                .terminals(cx)
+                .into_iter()
+                .find(|terminal| terminal.id == terminal_id)
+                .expect("terminal should remain in the panel");
+            assert!(!terminal.has_notification);
+        });
+        assert!(
+            cx.windows()
+                .iter()
+                .all(|window| window.downcast::<AgentNotification>().is_none())
+        );
+    }
+
+    #[gpui::test]
+    async fn test_terminal_bell_notifies_when_configuration_overlay_covers_terminal(
+        cx: &mut TestAppContext,
+    ) {
+        let (panel, mut cx) = setup_visible_panel(cx).await;
+        let terminal_id = panel
+            .update_in(&mut cx, |panel, window, cx| {
+                panel.insert_test_terminal("Claude", true, window, cx)
+            })
+            .expect("test terminal should be inserted");
+        cx.run_until_parked();
+
+        panel.update_in(&mut cx, |panel, window, cx| {
+            panel.set_overlay(OverlayView::Configuration, true, window, cx);
+        });
+        panel.update(&mut cx, |panel, cx| {
+            panel.emit_test_terminal_bell(terminal_id, cx);
+        });
+        cx.run_until_parked();
+
+        panel.read_with(&cx, |panel, cx| {
+            let terminal = panel
+                .terminals(cx)
+                .into_iter()
+                .find(|terminal| terminal.id == terminal_id)
+                .expect("terminal should remain in the panel");
+            assert!(terminal.has_notification);
+        });
+        cx.windows()
+            .iter()
+            .find_map(|window| window.downcast::<AgentNotification>())
+            .expect("covered terminal bell should show a notification");
+    }
+
+    #[gpui::test]
+    async fn test_thread_notification_shows_when_configuration_overlay_covers_thread(
+        cx: &mut TestAppContext,
+    ) {
+        let (panel, mut cx) = setup_visible_panel(cx).await;
+        let connection = StubAgentConnection::new();
+        connection.set_next_prompt_updates(vec![acp::SessionUpdate::AgentMessageChunk(
+            acp::ContentChunk::new("Default response".into()),
+        )]);
+        open_thread_with_connection(&panel, connection, &mut cx);
+
+        panel.update_in(&mut cx, |panel, window, cx| {
+            panel.set_overlay(OverlayView::Configuration, true, window, cx);
+        });
+        send_message(&panel, &mut cx);
+
+        cx.windows()
+            .iter()
+            .find_map(|window| window.downcast::<AgentNotification>())
+            .expect("covered thread should show a notification");
+    }
+
+    #[gpui::test]
+    async fn test_terminal_bell_marks_without_popup_when_sidebar_open(cx: &mut TestAppContext) {
+        let (panel, mut cx) = setup_visible_panel(cx).await;
+        let first_terminal_id = panel
+            .update_in(&mut cx, |panel, window, cx| {
+                panel.insert_test_terminal("Build", true, window, cx)
+            })
+            .expect("first test terminal should be inserted");
+        let second_terminal_id = panel
+            .update_in(&mut cx, |panel, window, cx| {
+                panel.insert_test_terminal("Server", true, window, cx)
+            })
+            .expect("second test terminal should be inserted");
+        cx.run_until_parked();
+
+        panel.read_with(&cx, |panel, _cx| {
+            assert_eq!(panel.active_terminal_id(), Some(second_terminal_id));
+        });
+        cx.update(|window, cx| {
+            let multi_workspace = window
+                .root::<MultiWorkspace>()
+                .flatten()
+                .expect("test window should have a MultiWorkspace root");
+            multi_workspace.update(cx, |multi_workspace, cx| {
+                multi_workspace.open_sidebar(cx);
+            });
+        });
+        cx.run_until_parked();
+
+        panel.update(&mut cx, |panel, cx| {
+            panel.emit_test_terminal_bell(first_terminal_id, cx);
+        });
+        cx.run_until_parked();
+
+        panel.read_with(&cx, |panel, cx| {
+            let first_terminal = panel
+                .terminals(cx)
+                .into_iter()
+                .find(|terminal| terminal.id == first_terminal_id)
+                .expect("first terminal should remain in the panel");
+            assert!(first_terminal.has_notification);
+        });
+        assert!(
+            cx.windows()
+                .iter()
+                .all(|window| window.downcast::<AgentNotification>().is_none())
+        );
+    }
+
+    #[gpui::test]
+    async fn test_terminal_bell_notifies_when_sidebar_history_open(cx: &mut TestAppContext) {
+        let (panel, mut cx) = setup_visible_panel_with_sidebar(cx, false).await;
+        let first_terminal_id = panel
+            .update_in(&mut cx, |panel, window, cx| {
+                panel.insert_test_terminal("Build", true, window, cx)
+            })
+            .expect("first test terminal should be inserted");
+        let second_terminal_id = panel
+            .update_in(&mut cx, |panel, window, cx| {
+                panel.insert_test_terminal("Server", true, window, cx)
+            })
+            .expect("second test terminal should be inserted");
+        cx.run_until_parked();
+
+        panel.read_with(&cx, |panel, _cx| {
+            assert_eq!(panel.active_terminal_id(), Some(second_terminal_id));
+        });
+        cx.update(|window, cx| {
+            let multi_workspace = window
+                .root::<MultiWorkspace>()
+                .flatten()
+                .expect("test window should have a MultiWorkspace root");
+            multi_workspace.update(cx, |multi_workspace, cx| {
+                multi_workspace.open_sidebar(cx);
+            });
+        });
+        cx.run_until_parked();
+
+        panel.update(&mut cx, |panel, cx| {
+            panel.emit_test_terminal_bell(first_terminal_id, cx);
+        });
+        cx.run_until_parked();
+
+        panel.read_with(&cx, |panel, cx| {
+            let first_terminal = panel
+                .terminals(cx)
+                .into_iter()
+                .find(|terminal| terminal.id == first_terminal_id)
+                .expect("first terminal should remain in the panel");
+            assert!(first_terminal.has_notification);
+        });
+        cx.windows()
+            .iter()
+            .find_map(|window| window.downcast::<AgentNotification>())
+            .expect("terminal bell should notify when the sidebar thread list is hidden");
+    }
+
+    #[gpui::test]
+    async fn test_terminal_notification_dismissed_when_sidebar_opens(cx: &mut TestAppContext) {
+        let (panel, mut cx) = setup_visible_panel(cx).await;
+        let first_terminal_id = panel
+            .update_in(&mut cx, |panel, window, cx| {
+                panel.insert_test_terminal("Build", true, window, cx)
+            })
+            .expect("first test terminal should be inserted");
+        let second_terminal_id = panel
+            .update_in(&mut cx, |panel, window, cx| {
+                panel.insert_test_terminal("Server", true, window, cx)
+            })
+            .expect("second test terminal should be inserted");
+        cx.run_until_parked();
+
+        panel.read_with(&cx, |panel, _cx| {
+            assert_eq!(panel.active_terminal_id(), Some(second_terminal_id));
+        });
+        panel.update(&mut cx, |panel, cx| {
+            panel.emit_test_terminal_bell(first_terminal_id, cx);
+        });
+        cx.run_until_parked();
+
+        cx.windows()
+            .iter()
+            .find_map(|window| window.downcast::<AgentNotification>())
+            .expect("inactive terminal bell should show a notification");
+
+        cx.update(|window, cx| {
+            let multi_workspace = window
+                .root::<MultiWorkspace>()
+                .flatten()
+                .expect("test window should have a MultiWorkspace root");
+            multi_workspace.update(cx, |multi_workspace, cx| {
+                multi_workspace.open_sidebar(cx);
+            });
+        });
+        cx.run_until_parked();
+
+        panel.read_with(&cx, |panel, cx| {
+            let first_terminal = panel
+                .terminals(cx)
+                .into_iter()
+                .find(|terminal| terminal.id == first_terminal_id)
+                .expect("first terminal should remain in the panel");
+            assert!(first_terminal.has_notification);
+        });
+        assert!(
+            cx.windows()
+                .iter()
+                .all(|window| window.downcast::<AgentNotification>().is_none())
+        );
+    }
+
+    #[gpui::test]
+    async fn test_focused_terminal_bell_notifies_when_window_inactive(cx: &mut TestAppContext) {
+        let (panel, mut cx) = setup_visible_panel(cx).await;
+        let terminal_id = panel
+            .update_in(&mut cx, |panel, window, cx| {
+                panel.insert_test_terminal("Claude", true, window, cx)
+            })
+            .expect("test terminal should be inserted");
+        cx.run_until_parked();
+
+        cx.update(|window, cx| {
+            assert!(window.is_window_active());
+            assert!(panel.read(cx).focus_handle(cx).contains_focused(window, cx));
+        });
+        cx.deactivate_window();
+        cx.update(|window, _cx| {
+            assert!(!window.is_window_active());
+        });
+
+        panel.update(&mut cx, |panel, cx| {
+            panel.emit_test_terminal_bell(terminal_id, cx);
+        });
+        cx.run_until_parked();
+
+        panel.read_with(&cx, |panel, cx| {
+            let terminal = panel
+                .terminals(cx)
+                .into_iter()
+                .find(|terminal| terminal.id == terminal_id)
+                .expect("terminal should remain in the panel");
+            assert!(terminal.has_notification);
+        });
+        cx.windows()
+            .iter()
+            .find_map(|window| window.downcast::<AgentNotification>())
+            .expect("background terminal bell should show a notification");
+    }
+
+    #[gpui::test]
+    async fn test_active_terminal_notification_clears_when_window_reactivates(
+        cx: &mut TestAppContext,
+    ) {
+        let (panel, mut cx) = setup_visible_panel(cx).await;
+        let terminal_id = panel
+            .update_in(&mut cx, |panel, window, cx| {
+                panel.insert_test_terminal("Claude", true, window, cx)
+            })
+            .expect("test terminal should be inserted");
+        cx.run_until_parked();
+
+        cx.deactivate_window();
+        panel.update(&mut cx, |panel, cx| {
+            panel.emit_test_terminal_bell(terminal_id, cx);
+        });
+        cx.run_until_parked();
+
+        panel.read_with(&cx, |panel, cx| {
+            let terminal = panel
+                .terminals(cx)
+                .into_iter()
+                .find(|terminal| terminal.id == terminal_id)
+                .expect("terminal should remain in the panel");
+            assert!(terminal.has_notification);
+        });
+        cx.windows()
+            .iter()
+            .find_map(|window| window.downcast::<AgentNotification>())
+            .expect("background terminal bell should show a notification");
+
+        cx.update(|window, _cx| {
+            window.activate_window();
+        });
+        cx.run_until_parked();
+
+        panel.read_with(&cx, |panel, cx| {
+            let terminal = panel
+                .terminals(cx)
+                .into_iter()
+                .find(|terminal| terminal.id == terminal_id)
+                .expect("terminal should remain in the panel");
+            assert!(!terminal.has_notification);
+        });
+        assert!(
+            cx.windows()
+                .iter()
+                .all(|window| window.downcast::<AgentNotification>().is_none())
+        );
+    }
+
+    #[gpui::test]
+    async fn test_terminal_notification_dismissed_when_active_terminal_becomes_visible(
+        cx: &mut TestAppContext,
+    ) {
+        let (panel, mut cx) = setup_panel(cx).await;
+        cx.update(|_window, cx| {
+            AgentSettings::override_global(
+                AgentSettings {
+                    notify_when_agent_waiting: NotifyWhenAgentWaiting::PrimaryScreen,
+                    ..AgentSettings::get_global(cx).clone()
+                },
+                cx,
+            );
+        });
+        let terminal_id = panel
+            .update_in(&mut cx, |panel, window, cx| {
+                panel.insert_test_terminal("Claude", true, window, cx)
+            })
+            .expect("test terminal should be inserted");
+        cx.run_until_parked();
+
+        panel.update(&mut cx, |panel, cx| {
+            panel.emit_test_terminal_bell(terminal_id, cx);
+        });
+        cx.run_until_parked();
+
+        panel.read_with(&cx, |panel, cx| {
+            let terminal = panel
+                .terminals(cx)
+                .into_iter()
+                .find(|terminal| terminal.id == terminal_id)
+                .expect("terminal should remain in the panel");
+            assert!(terminal.has_notification);
+        });
+        cx.windows()
+            .iter()
+            .find_map(|window| window.downcast::<AgentNotification>())
+            .expect("hidden terminal bell should show a notification");
+
+        let workspace = cx.update(|window, cx| {
+            window
+                .root::<MultiWorkspace>()
+                .flatten()
+                .expect("test window should have a MultiWorkspace root")
+                .read(cx)
+                .workspace()
+                .clone()
+        });
+        workspace.update_in(&mut cx, |workspace, window, cx| {
+            workspace.add_panel(panel.clone(), window, cx);
+            workspace.focus_panel::<AgentPanel>(window, cx);
+        });
+        cx.run_until_parked();
+
+        panel.read_with(&cx, |panel, cx| {
+            let terminal = panel
+                .terminals(cx)
+                .into_iter()
+                .find(|terminal| terminal.id == terminal_id)
+                .expect("terminal should remain in the panel");
+            assert!(!terminal.has_notification);
+        });
+        assert!(
+            cx.windows()
+                .iter()
+                .all(|window| window.downcast::<AgentNotification>().is_none())
+        );
+    }
+
+    #[gpui::test]
+    async fn test_terminal_notification_closed_when_panel_dropped(cx: &mut TestAppContext) {
+        let (panel, mut cx) = setup_panel(cx).await;
+        cx.update(|_window, cx| {
+            AgentSettings::override_global(
+                AgentSettings {
+                    notify_when_agent_waiting: NotifyWhenAgentWaiting::PrimaryScreen,
+                    ..AgentSettings::get_global(cx).clone()
+                },
+                cx,
+            );
+        });
+        let terminal_id = panel
+            .update_in(&mut cx, |panel, window, cx| {
+                panel.insert_test_terminal("Claude", true, window, cx)
+            })
+            .expect("test terminal should be inserted");
+        let weak_panel = panel.downgrade();
+        cx.run_until_parked();
+
+        panel.update(&mut cx, |panel, cx| {
+            panel.emit_test_terminal_bell(terminal_id, cx);
+        });
+        cx.run_until_parked();
+
+        cx.windows()
+            .iter()
+            .find_map(|window| window.downcast::<AgentNotification>())
+            .expect("hidden terminal bell should show a notification");
+
+        drop(panel);
+        cx.update(|_window, _cx| {});
+        cx.run_until_parked();
+
+        assert!(
+            !weak_panel.is_upgradable(),
+            "agent panel should be released after dropping the last handle"
+        );
+        assert!(
+            cx.windows()
+                .iter()
+                .all(|window| window.downcast::<AgentNotification>().is_none())
+        );
+    }
+
     #[gpui::test]
     async fn test_terminal_notification_view_activates_terminal_workspace(cx: &mut TestAppContext) {
         init_test(cx);
@@ -8656,6 +9268,11 @@ mod tests {
         notification
             .update(cx, |notification, _window, cx| notification.accept(cx))
             .unwrap();
+        assert!(
+            cx.windows()
+                .iter()
+                .all(|window| window.downcast::<AgentNotification>().is_none())
+        );
         cx.run_until_parked();
 
         multi_workspace
diff --git a/crates/agent_ui/src/conversation_view.rs b/crates/agent_ui/src/conversation_view.rs
index 5e5f6af52b3..96d6476b9a3 100644
--- a/crates/agent_ui/src/conversation_view.rs
+++ b/crates/agent_ui/src/conversation_view.rs
@@ -2533,18 +2533,24 @@ impl ConversationView {
             return false;
         };
 
-        multi_workspace.read(cx).sidebar_open()
-            || multi_workspace.read(cx).workspace() == &workspace
-                && AgentPanel::is_visible(&workspace, cx)
-                && multi_workspace
-                    .read(cx)
-                    .workspace()
-                    .read(cx)
-                    .panel::<AgentPanel>(cx)
-                    .map_or(false, |p| {
-                        p.read(cx).active_conversation_view().map(|c| c.entity_id())
-                            == Some(cx.entity_id())
-                    })
+        let multi_workspace = multi_workspace.read(cx);
+        multi_workspace.sidebar_open() && multi_workspace.is_threads_list_view_active(cx)
+            || multi_workspace.workspace() == &workspace
+                && self.is_visible_in_agent_panel(&workspace, cx)
+    }
+
+    fn is_visible_in_agent_panel(&self, workspace: &Entity<Workspace>, cx: &Context<Self>) -> bool {
+        AgentPanel::is_visible(workspace, cx)
+            && workspace
+                .read(cx)
+                .panel::<AgentPanel>(cx)
+                .is_some_and(|panel| {
+                    panel
+                        .read(cx)
+                        .visible_conversation_view()
+                        .map(|conversation_view| conversation_view.entity_id())
+                        == Some(cx.entity_id())
+                })
     }
 
     fn agent_status_visible(&self, window: &Window, cx: &Context<Self>) -> bool {
@@ -2557,7 +2563,7 @@ impl ConversationView {
         } else {
             self.workspace
                 .upgrade()
-                .is_some_and(|workspace| AgentPanel::is_visible(&workspace, cx))
+                .is_some_and(|workspace| self.is_visible_in_agent_panel(&workspace, cx))
         }
     }
 
@@ -2569,7 +2575,7 @@ impl ConversationView {
             } else {
                 self.workspace
                     .upgrade()
-                    .is_some_and(|workspace| AgentPanel::is_visible(&workspace, cx))
+                    .is_some_and(|workspace| self.is_visible_in_agent_panel(&workspace, cx))
             };
         let settings = AgentSettings::get_global(cx);
         if settings.play_sound_when_agent_done.should_play(visible) {
@@ -3179,6 +3185,7 @@ pub(crate) mod tests {
 
     use crate::agent_panel;
     use crate::completion_provider::AgentContextSource;
+    use crate::test_support::register_test_sidebar;
     use crate::thread_metadata_store::ThreadMetadataStore;
 
     use super::*;
@@ -4164,6 +4171,7 @@ pub(crate) mod tests {
             .unwrap();
 
         let cx = &mut VisualTestContext::from_window(multi_workspace_handle.into(), cx);
+        register_test_sidebar(true, cx);
 
         // Open the sidebar so that sidebar_open() returns true.
         multi_workspace_handle
@@ -4228,6 +4236,80 @@ pub(crate) mod tests {
         );
     }
 
+    #[gpui::test]
+    async fn test_notification_when_sidebar_open_but_thread_list_hidden(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+
+        cx.update(|cx| {
+            cx.update_flags(true, vec!["agent-v2".to_string()]);
+            agent::ThreadStore::init_global(cx);
+            language_model::LanguageModelRegistry::test(cx);
+            <dyn Fs>::set_global(fs.clone(), cx);
+        });
+
+        let project = Project::test(fs, [], cx).await;
+        let multi_workspace_handle =
+            cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
+
+        let workspace = multi_workspace_handle
+            .read_with(cx, |mw, _cx| mw.workspace().clone())
+            .unwrap();
+
+        let cx = &mut VisualTestContext::from_window(multi_workspace_handle.into(), cx);
+        register_test_sidebar(false, cx);
+        multi_workspace_handle
+            .update(cx, |mw, _window, cx| {
+                mw.open_sidebar(cx);
+            })
+            .unwrap();
+        cx.run_until_parked();
+
+        let thread_store = cx.update(|_window, cx| cx.new(|cx| ThreadStore::new(cx)));
+        let connection_store =
+            cx.update(|_window, cx| cx.new(|cx| AgentConnectionStore::new(project.clone(), cx)));
+
+        let conversation_view = cx.update(|window, cx| {
+            cx.new(|cx| {
+                ConversationView::new(
+                    Rc::new(StubAgentServer::default_response()),
+                    connection_store,
+                    Agent::Custom { id: "Test".into() },
+                    None,
+                    None,
+                    None,
+                    None,
+                    None,
+                    workspace.downgrade(),
+                    project.clone(),
+                    Some(thread_store),
+                    None,
+                    AgentThreadSource::AgentPanel,
+                    window,
+                    cx,
+                )
+            })
+        });
+        cx.run_until_parked();
+
+        let message_editor = message_editor(&conversation_view, cx);
+        message_editor.update_in(cx, |editor, window, cx| {
+            editor.set_text("Hello", window, cx);
+        });
+
+        active_thread(&conversation_view, cx)
+            .update_in(cx, |view, window, cx| view.send(window, cx));
+        cx.run_until_parked();
+
+        assert!(
+            cx.windows()
+                .iter()
+                .any(|window| window.downcast::<AgentNotification>().is_some()),
+            "Expected notification when the sidebar is open but the thread list is hidden"
+        );
+    }
+
     #[gpui::test]
     async fn test_notification_dismissed_when_sidebar_opens(cx: &mut TestAppContext) {
         init_test(cx);
@@ -4250,6 +4332,7 @@ pub(crate) mod tests {
             .unwrap();
 
         let cx = &mut VisualTestContext::from_window(multi_workspace_handle.into(), cx);
+        register_test_sidebar(true, cx);
 
         let thread_store = cx.update(|_window, cx| cx.new(|cx| ThreadStore::new(cx)));
         let connection_store =
diff --git a/crates/agent_ui/src/test_support.rs b/crates/agent_ui/src/test_support.rs
index 509dfdbb559..3f8d5c8c6df 100644
--- a/crates/agent_ui/src/test_support.rs
+++ b/crates/agent_ui/src/test_support.rs
@@ -1,13 +1,17 @@
 use acp_thread::{AgentConnection, StubAgentConnection};
 use agent_client_protocol::schema as acp;
 use agent_servers::{AgentServer, AgentServerDelegate};
-use gpui::{Entity, Task, TestAppContext, VisualTestContext};
+use gpui::{
+    App, AppContext as _, Context, Entity, EventEmitter, FocusHandle, Focusable, IntoElement,
+    Pixels, Render, Task, TestAppContext, VisualTestContext, Window, div, px,
+};
 use project::AgentId;
 use project::Project;
 use settings::SettingsStore;
 use std::any::Any;
 use std::cell::RefCell;
 use std::rc::Rc;
+use workspace::{MultiWorkspace, Sidebar as WorkspaceSidebar, SidebarEvent, SidebarSide};
 
 use crate::AgentPanel;
 use crate::agent_panel;
@@ -109,6 +113,71 @@ pub fn init_test(cx: &mut TestAppContext) {
     });
 }
 
+pub struct TestWorkspaceSidebar {
+    focus_handle: FocusHandle,
+    threads_list_active: bool,
+}
+
+impl TestWorkspaceSidebar {
+    fn new(threads_list_active: bool, cx: &mut Context<Self>) -> Self {
+        Self {
+            focus_handle: cx.focus_handle(),
+            threads_list_active,
+        }
+    }
+}
+
+impl EventEmitter<SidebarEvent> for TestWorkspaceSidebar {}
+
+impl Focusable for TestWorkspaceSidebar {
+    fn focus_handle(&self, _cx: &App) -> FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl WorkspaceSidebar for TestWorkspaceSidebar {
+    fn width(&self, _cx: &App) -> Pixels {
+        px(300.)
+    }
+
+    fn set_width(&mut self, _width: Option<Pixels>, _cx: &mut Context<Self>) {}
+
+    fn has_notifications(&self, _cx: &App) -> bool {
+        false
+    }
+
+    fn side(&self, _cx: &App) -> SidebarSide {
+        SidebarSide::Left
+    }
+
+    fn is_threads_list_view_active(&self) -> bool {
+        self.threads_list_active
+    }
+}
+
+impl Render for TestWorkspaceSidebar {
+    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
+        div()
+    }
+}
+
+pub fn register_test_sidebar(
+    threads_list_active: bool,
+    cx: &mut VisualTestContext,
+) -> Entity<TestWorkspaceSidebar> {
+    cx.update(|window, cx| {
+        let multi_workspace = window
+            .root::<MultiWorkspace>()
+            .flatten()
+            .expect("test window should have a MultiWorkspace root");
+        let sidebar = cx.new(|cx| TestWorkspaceSidebar::new(threads_list_active, cx));
+        multi_workspace.update(cx, |multi_workspace, cx| {
+            multi_workspace.register_sidebar(sidebar.clone(), cx);
+        });
+        sidebar
+    })
+}
+
 pub fn open_thread_with_connection(
     panel: &Entity<AgentPanel>,
     connection: StubAgentConnection,

From 43b7ca9cc24f2d5ba06e47940235ddb020939b80 Mon Sep 17 00:00:00 2001
From: Ben Brandt <benjamin.j.brandt@gmail.com>
Date: Wed, 20 May 2026 15:13:00 +0200
Subject: [PATCH 061/105] terminal: Fix pty info change detection race (#57257)

I think I introduced this at some point in the terminal agent situation.

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Release Notes:

- N/A
---
 crates/terminal/src/pty_info.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/crates/terminal/src/pty_info.rs b/crates/terminal/src/pty_info.rs
index 4e16d69e405..96908479afe 100644
--- a/crates/terminal/src/pty_info.rs
+++ b/crates/terminal/src/pty_info.rs
@@ -192,8 +192,9 @@ impl PtyProcessInfo {
         }
         let this = self.clone();
         let has_changed = cx.background_executor().spawn(async move {
+            let previous = this.current.read().clone();
             let current = this.load();
-            let has_changed = match (this.current.read().as_ref(), current.as_ref()) {
+            let has_changed = match (previous.as_ref(), current.as_ref()) {
                 (None, None) => false,
                 (Some(prev), Some(now)) => prev.cwd != now.cwd || prev.name != now.name,
                 _ => true,

From a4c6a8392d903dfaa9f4cdf25ed45fea1e7fcfd0 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Wed, 20 May 2026 11:00:43 -0300
Subject: [PATCH 062/105] settings_ui: Fix skills link (#57265)

This PR ensures clicking to copy the skills link in the settings UI
works properly.

Release Notes:

- N/A
---
 crates/settings_ui/src/page_data.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/settings_ui/src/page_data.rs b/crates/settings_ui/src/page_data.rs
index 327f64b7dc5..3eb1ec94512 100644
--- a/crates/settings_ui/src/page_data.rs
+++ b/crates/settings_ui/src/page_data.rs
@@ -7487,7 +7487,7 @@ fn ai_page(cx: &App) -> SettingsPage {
             SettingsPageItem::SubPageLink(SubPageLink {
                 title: "Skills".into(),
                 r#type: Default::default(),
-                json_path: None,
+                json_path: Some("agent.skills"),
                 description: Some("View and manage agent skills installed globally or in project worktrees.".into()),
                 in_json: false,
                 files: USER | PROJECT,

From dd528e3efbb5c5632cc9e5cb162c0159b79f6ea6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mar=C3=ADa=20Craig?= <maria@zed.dev>
Date: Wed, 20 May 2026 11:10:59 -0300
Subject: [PATCH 063/105] docs: Add Skills documentation (#57095)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds documentation for the new Skills feature, which replaces Rules
starting in Zed v1.4.0.

## Changes

- **New page**: `docs/src/ai/skills.md` — covers what skills are,
finding and installing skills from skills.sh, using skills via slash
commands and model invocation, creating a skill (folder structure,
SKILL.md format, frontmatter fields, bundled resources), where skills
live (global vs project-local), security model, and limitations
- **Updated**: `docs/src/ai/rules.md` — added deprecation notice
pointing to Skills
- **Updated**: `docs/src/SUMMARY.md` — added Skills entry above Rules in
the AI section
- **Updated**: `docs/src/ai/agent-panel.md` — replaced reference to
"rules files" with "skills" in the Adding Context section

Release Notes:

- Added documentation for the Skills feature

---------

Co-authored-by: zed-zippy[bot] <234243425+zed-zippy[bot]@users.noreply.github.com>
Co-authored-by: Danilo Leal <daniloleal09@gmail.com>
---
 docs/src/SUMMARY.md        |   1 +
 docs/src/ai/agent-panel.md |   2 +-
 docs/src/ai/rules.md       |  17 ++--
 docs/src/ai/skills.md      | 186 +++++++++++++++++++++++++++++++++++++
 4 files changed, 198 insertions(+), 8 deletions(-)
 create mode 100644 docs/src/ai/skills.md

diff --git a/docs/src/SUMMARY.md b/docs/src/SUMMARY.md
index 606a75542a5..eca2ca57ae4 100644
--- a/docs/src/SUMMARY.md
+++ b/docs/src/SUMMARY.md
@@ -18,6 +18,7 @@
 - [Parallel Agents](./ai/parallel-agents.md)
 - [Inline Assistant](./ai/inline-assistant.md)
 - [Edit Prediction](./ai/edit-prediction.md)
+- [Skills](./ai/skills.md)
 - [Rules](./ai/rules.md)
 - [Model Context Protocol](./ai/mcp.md)
 - [Configuration](./ai/configuration.md)
diff --git a/docs/src/ai/agent-panel.md b/docs/src/ai/agent-panel.md
index 77c052d4841..95588b025f2 100644
--- a/docs/src/ai/agent-panel.md
+++ b/docs/src/ai/agent-panel.md
@@ -234,7 +234,7 @@ terminal_title = ["spinner", "project-name", "run-state", "thread-title"]
 The agent can search your codebase to find relevant context, but providing it explicitly improves response quality and reduces latency.
 
 Add context by typing `@` in the message editor.
-You can mention files, directories, symbols, previous threads, rules files, and diagnostics.
+You can mention files, directories, symbols, previous threads, skills, and diagnostics.
 
 When you paste multi-line code selections copied from a buffer, Zed automatically formats them as @-mentions with the file context.
 To paste content without this automatic formatting, use {#kb agent::PasteRaw} to paste raw text directly.
diff --git a/docs/src/ai/rules.md b/docs/src/ai/rules.md
index 1fb47aa562d..9258be157e6 100644
--- a/docs/src/ai/rules.md
+++ b/docs/src/ai/rules.md
@@ -3,10 +3,12 @@ title: AI Rules in Zed - .rules, .cursorrules, CLAUDE.md
 description: Configure AI behavior in Zed with .rules files, .cursorrules, CLAUDE.md, AGENTS.md, and the Rules Library for project-level instructions.
 ---
 
-# Using Rules {#using-rules}
+# Rules {#rules}
 
 Rules are prompts that can be inserted either automatically at the beginning of each [Agent Panel](./agent-panel.md) interaction, through `.rules` files available in your project's file tree, or on-demand, through @-mentioning, via the Rules Library.
 
+> **Note:** Starting in Zed v1.4.0, on-demand rules (and the rules library) have been replaced by [Skills](./skills.md). Skills are the recommended way to package reusable agent instructions. Learn more about [the rules -> skills migration](#migrating-to-skills).
+
 ## `.rules` files
 
 Zed supports including `.rules` files at the root of a project's file tree, and they act as project-level instructions that are auto-included in all of your interactions with the Agent Panel.
@@ -30,6 +32,8 @@ It's a full editor with syntax highlighting and all standard keybindings.
 
 You can also use the inline assistant right in the rules editor, allowing you to get quick LLM support for writing rules.
 
+> **Note:** Starting in Zed v1.4.0, the rules library has been replaced by [Skills](./skills.md). Skills are the recommended way to package reusable agent instructions. Learn more about [the rules -> skills migration](#migrating-to-skills).
+
 ### Opening the Rules Library
 
 1. Open the Agent Panel.
@@ -66,12 +70,11 @@ All rules in the Rules Library can be set as a default rule, which means they’
 
 You can set any rule as the default by clicking the paper clip icon button in the top-right of the rule editor in the Rules Library.
 
-## Migrating from Prompt Library
+## Migrating to Skills {#migrating-to-skills}
 
-Previously, the Rules Library was called the "Prompt Library".
-The new rules system replaces the Prompt Library except in a few specific cases, which are outlined below.
+When you update to Zed v1.4.0, your existing Rules are migrated to Skills automatically:
 
-### Slash Commands in Rules
+- **Non-default Rules** become global skills in `~/.agents/skills/`, each with `disable-model-invocation: true`. They remain user-invocable via `/skill-name` or `@`-mention.
+- **Default Rules** are appended to your global `AGENTS.md` file (`~/.config/zed/AGENTS.md` on macOS and Linux, `%APPDATA%\Zed\AGENTS.md` on Windows), preserving their behavior of being included in every conversation.
 
-Previously, it was possible to use slash commands (now @-mentions) in custom prompts (now rules).
-There is currently no support for using @-mentions in rules files.
+A banner in the title bar announces the migration when it runs. Your original Rule data is not deleted, so downgrading to an earlier version of Zed leaves your Rules intact.
diff --git a/docs/src/ai/skills.md b/docs/src/ai/skills.md
new file mode 100644
index 00000000000..25ffebc9728
--- /dev/null
+++ b/docs/src/ai/skills.md
@@ -0,0 +1,186 @@
+---
+title: Agent Skills - Zed
+description: Extend Zed's AI agent with reusable, on-demand skill files for specialized tasks.
+---
+
+# Skills {#skills}
+
+Skills are reusable instruction packages that give the agent specialized knowledge for specific tasks: test-driven development workflows, document processing, database integrations, or your team's internal coding standards.
+
+A skill is a folder containing a `SKILL.md` file with metadata and instructions. The agent sees a catalog of all installed skills and can load one on demand, or you can invoke any skill directly from the message editor with a slash command.
+
+## Adding Skills {#adding-skills}
+
+### Create Your Own {#create-your-own}
+
+Zed includes a built-in `create-skill` skill that guides the agent through creating a new skill. Invoke it with `/create-skill`, or let the agent pick it up automatically when you ask it to help create a skill.
+
+See [Skill format](#skill-format) below for the folder structure and `SKILL.md` reference.
+
+### From the skills.sh Registry {#from-the-registry}
+
+[skills.sh](https://skills.sh) is a community registry of open-source skills. You'll find skills for popular frameworks, tools, workflows, and more:
+
+- [`find-skills`](https://skills.sh/vercel-labs/skills/find-skills): discover and install skills from the open ecosystem
+- [`frontend-design`](https://skills.sh/anthropics/skills/frontend-design): production-grade frontend interfaces with design polish
+- [`pdf`](https://skills.sh/anthropics/skills/pdf): PDF text extraction, merging, splitting, form filling, and OCR
+
+To install a skill from it, copy or clone its folder into your global or project-local skills folder.
+
+For example, to install the `frontend-design` skill from GitHub globally:
+
+```sh
+cd ~/.agents/skills
+git clone --filter=blob:none --sparse https://github.com/anthropics/skills
+cd skills
+git sparse-checkout set frontend-design
+```
+
+For a project-local install, do the same inside your project's `.agents/skills/` folder.
+
+## Using Skills {#using-skills}
+
+By default, the agent picks up skills autonomously. It sees a catalog of every installed skill (name and description) in its system prompt, and calls the `skill` tool when a task matches a skill's description.
+
+When the agent invokes a skill, Zed prompts you to allow or deny it, using the same permission flow as other tools. You can set per-skill defaults in [Tool Permissions](./tool-permissions.md) so you're not prompted for skills you always trust.
+
+### Manual Invocation {#manual-invocation}
+
+You can also load a skill manually:
+
+- **Slash command**: type `/` in the message editor and select a skill by name
+- **@-mention**: type `@skill` in the message editor and select a skill from the completion menu
+
+Both inject the skill's instructions as context. The loaded skill appears as a crease button in the thread, which you can click to open the skill file.
+
+### Preventing Autonomous Invocation {#disable-model-invocation}
+
+Add `disable-model-invocation: true` to a skill's frontmatter to stop the agent from picking it up autonomously.
+The skill still appears as a slash command, so you stay in control of when it runs.
+
+This is useful for workflows you don't want the agent triggering automatically, like deploy or release procedures.
+
+```yaml
+---
+name: deploy
+description: Deploy the current branch to production.
+disable-model-invocation: true
+---
+```
+
+## Skill Format {#skill-format}
+
+### Folder Structure {#folder-structure}
+
+A skill is a named folder containing a `SKILL.md` file:
+
+```
+my-skill/
+├── SKILL.md          # Required: metadata and instructions
+├── scripts/          # Optional: scripts the agent can run
+├── references/       # Optional: additional documentation
+└── assets/           # Optional: templates and static files
+```
+
+The folder name must match the `name` field in `SKILL.md`.
+
+### SKILL.md format {#skill-md-format}
+
+`SKILL.md` starts with YAML frontmatter, followed by Markdown instructions.
+
+**Minimal example:**
+
+```markdown
+---
+name: my-skill
+description: What this skill does and when to use it.
+---
+
+## Instructions
+
+Step-by-step instructions for the agent...
+```
+
+#### Frontmatter Fields {#frontmatter-fields}
+
+| Field                      | Required | Description                                                                                  |
+| -------------------------- | -------- | -------------------------------------------------------------------------------------------- |
+| `name`                     | Yes      | Lowercase letters, numbers, and hyphens only. Max 64 characters. Must match the folder name. |
+| `description`              | Yes      | What the skill does and when to use it. Max 1024 characters.                                 |
+| `disable-model-invocation` | No       | Set to `true` to hide from the agent's catalog (slash command only).                         |
+
+> **Tip:** Write descriptions that help the agent recognize when a skill is relevant. Include specific task types and trigger phrases: "Use when handling PDFs, extracting text, or filling forms" is better than "Helps with PDFs."
+
+We plan to include other fields promoted by [the Agent Skills specification](https://agentskills.io/specification) in the near future.
+
+#### Name Validation {#name-validation}
+
+The `name` field must:
+
+- Contain only lowercase letters (`a-z`), numbers, and hyphens
+- Not start or end with a hyphen
+- Not contain consecutive hyphens (`--`)
+- Be 1 to 64 characters
+
+Skills with invalid names fail to load and surface an error in the UI.
+
+### Bundled Resources {#bundled-resources}
+
+Keep the body of `SKILL.md` under 500 lines. Move detailed material to reference files and link to them from the body:
+
+```markdown
+See [reference guide](references/REFERENCE.md) for complete API details.
+
+Run the extraction script:
+scripts/extract.py
+```
+
+The agent loads these files on demand using the `read_file` and `list_directory` tools. Global skills under `~/.agents/skills/` are accessible to the agent even though they're outside your project.
+
+### Writing Effective Instructions {#writing-instructions}
+
+Skills use [progressive disclosure](https://agentskills.io/specification#progressive-disclosure): the agent sees only the name and description until it activates a skill, then loads the full body. Structure your skill to take advantage of this:
+
+- Put the most important instructions near the top of the body
+- Keep `SKILL.md` under 500 lines; move detailed references to `references/`
+- Scripts that the agent needs to run go in `scripts/`
+
+See the [Agent Skills specification](https://agentskills.io/specification) for the full format reference.
+
+## Where Skills Live {#where-skills-live}
+
+Zed loads skills from two locations:
+
+| Scope         | Path                         | When it applies          |
+| ------------- | ---------------------------- | ------------------------ |
+| Global        | `~/.agents/skills/`          | Every project            |
+| Project-local | `<worktree>/.agents/skills/` | Only the current project |
+
+Each skill is a direct child of the skills root. Nesting skills inside subfolders is not supported.
+
+### Project-local Skills and Trust {#project-local-trust}
+
+Project-local skills only load from [trusted worktrees](../worktree-trust.md). Skills from a freshly cloned or untrusted project are excluded from the catalog and slash commands until you grant trust.
+
+This prevents a malicious project from injecting instructions into your agent's system prompt before you've reviewed what the project ships.
+
+### Override Behavior {#override-behavior}
+
+If a global and a project-local skill share the same name, the project-local skill takes precedence. This lets a project customize or replace a global skill for its own context.
+
+### Editing Skill Files {#editing-skill-files}
+
+The agent cannot edit `SKILL.md` files or their bundled resources without your explicit authorization, even in a trusted project. This prevents a compromised conversation from modifying the skills that govern future conversations.
+
+## Limitations {#limitations}
+
+- **Flat layout only.** Skills must be direct children of the skills root. Nested folders like `~/.agents/skills/group/my-skill/` are not discovered.
+- **50KB catalog budget.** The total size of all skill names and descriptions is capped at 50KB. Skills that don't fit are dropped from the catalog with a warning in the UI. Keep descriptions concise.
+- **No remote registry.** Zed does not fetch skills from URLs or support custom search paths. Skills come from `~/.agents/skills/` and `<worktree>/.agents/skills/` only. Use a symlink if you need to point at another location.
+- **Live reload.** Adding, removing, or editing a `SKILL.md` takes effect immediately without restarting your session. Changes to a skill's `name` or `description` invalidate the model's prompt cache for the current session.
+
+## See also
+
+- [Agent Panel](./agent-panel.md)
+- [Tool Permissions](./tool-permissions.md)
+- [Agent Skills specification](https://agentskills.io/specification)

From 80c0f7de0a39414742be87691738a275c59f2277 Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Wed, 20 May 2026 16:12:42 +0200
Subject: [PATCH 064/105] Stop building semantic highlights on the main thread
 (#57264)

Trace on `main` that showed the hogged main thread:
[Sample of Zed
Nightly.txt](https://github.com/user-attachments/files/28060310/Sample.of.Zed.Nightly.txt)


Release Notes:

- N/A
---
 .../src/highlights_tree_view.rs               | 556 +++++++++++-------
 1 file changed, 355 insertions(+), 201 deletions(-)

diff --git a/crates/language_tools/src/highlights_tree_view.rs b/crates/language_tools/src/highlights_tree_view.rs
index 96f673fa1dc..1b58e830153 100644
--- a/crates/language_tools/src/highlights_tree_view.rs
+++ b/crates/language_tools/src/highlights_tree_view.rs
@@ -10,8 +10,9 @@ use gpui::{
 };
 use language::{BufferId, Point, ToOffset};
 use menu::{SelectNext, SelectPrevious};
-use std::{mem, ops::Range};
+use std::{mem, ops::Range, sync::Arc, time::Duration};
 use theme::ActiveTheme;
+use theme::SyntaxTheme;
 use ui::{
     ButtonCommon, ButtonLike, ButtonStyle, Color, ContextMenu, FluentBuilder as _, IconButton,
     IconName, IconPosition, IconSize, Label, LabelCommon, LabelSize, PopoverMenu,
@@ -147,6 +148,7 @@ pub struct HighlightsTreeView {
     show_syntax_tokens: bool,
     show_semantic_tokens: bool,
     skip_next_scroll: bool,
+    refresh_task: Task<()>,
 }
 
 pub struct HighlightsTreeToolbarItemView {
@@ -160,6 +162,19 @@ struct EditorState {
     _subscription: gpui::Subscription,
 }
 
+struct SemanticHighlightEntry {
+    range: Range<Anchor>,
+    style: HighlightStyle,
+    category: HighlightCategory,
+}
+
+struct HighlightRefreshInput {
+    multi_buffer_snapshot: MultiBufferSnapshot,
+    text_highlights: Vec<(HighlightKey, Arc<(HighlightStyle, Vec<Range<Anchor>>)>)>,
+    semantic_highlights: Vec<SemanticHighlightEntry>,
+    syntax_theme: Arc<SyntaxTheme>,
+}
+
 impl HighlightsTreeView {
     pub fn new(
         workspace_handle: WeakEntity<Workspace>,
@@ -181,6 +196,7 @@ impl HighlightsTreeView {
             show_syntax_tokens: true,
             show_semantic_tokens: true,
             skip_next_scroll: false,
+            refresh_task: Task::ready(()),
         };
 
         this.handle_item_updated(active_item, window, cx);
@@ -254,6 +270,7 @@ impl HighlightsTreeView {
     }
 
     fn clear(&mut self, cx: &mut Context<Self>) {
+        self.refresh_task = Task::ready(());
         self.cached_entries.clear();
         self.display_items.clear();
         self.selected_item_ix = None;
@@ -274,9 +291,9 @@ impl HighlightsTreeView {
 
         let subscription =
             cx.subscribe_in(&editor, window, |this, _, event, window, cx| match event {
-                editor::EditorEvent::Reparsed(_)
-                | editor::EditorEvent::SelectionsChanged { .. } => {
-                    this.refresh_highlights(window, cx);
+                editor::EditorEvent::Reparsed(_) => this.schedule_refresh_highlights(window, cx),
+                editor::EditorEvent::SelectionsChanged { .. } => {
+                    this.update_selection_from_editor(cx);
                 }
                 _ => return,
             });
@@ -285,221 +302,152 @@ impl HighlightsTreeView {
             editor,
             _subscription: subscription,
         });
-        self.refresh_highlights(window, cx);
+        self.refresh_task = Task::ready(());
+        self.cached_entries.clear();
+        self.display_items.clear();
+        self.selected_item_ix = None;
+        self.hovered_item_ix = None;
+        self.schedule_refresh_highlights(window, cx);
+        cx.notify();
     }
 
-    fn refresh_highlights(&mut self, _window: &mut Window, cx: &mut Context<Self>) {
-        let Some(editor_state) = self.editor.as_ref() else {
-            self.clear(cx);
-            return;
-        };
+    fn schedule_refresh_highlights(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        self.refresh_task = cx.spawn_in(window, async move |this, cx| {
+            cx.background_executor()
+                .timer(Duration::from_millis(30))
+                .await;
 
-        let (display_map, project, multi_buffer, cursor_position) = {
-            let editor = editor_state.editor.read(cx);
-            let cursor = editor.selections.newest_anchor().head();
-            (
-                editor.display_map.clone(),
-                editor.project().cloned(),
-                editor.buffer().clone(),
-                cursor,
-            )
-        };
-        let Some(project) = project else {
-            return;
-        };
+            let Some(input) = this
+                .update(cx, |this, cx| this.highlight_refresh_input(cx))
+                .ok()
+                .flatten()
+            else {
+                return;
+            };
 
+            let new_highlights = cx
+                .background_spawn(async move { build_highlight_entries(input) })
+                .await;
+
+            this.update_in(cx, |this, _window, cx| {
+                this.apply_highlight_refresh(new_highlights, cx);
+            })
+            .ok();
+        });
+    }
+
+    fn highlight_refresh_input(&self, cx: &mut Context<Self>) -> Option<HighlightRefreshInput> {
+        let editor_state = self.editor.as_ref()?;
+        let editor = editor_state.editor.read(cx);
+        let display_map = editor.display_map.clone();
+        let project = editor.project().cloned()?;
+        let multi_buffer = editor.buffer().clone();
         let multi_buffer_snapshot = multi_buffer.read(cx).snapshot(cx);
-        let is_singleton = multi_buffer_snapshot.is_singleton();
-        self.is_singleton = is_singleton;
+        let syntax_theme = cx.theme().syntax().clone();
 
-        let mut entries = Vec::new();
+        let (text_highlights, semantic_token_highlights) =
+            display_map.update(cx, |display_map, _| {
+                let text_highlights = display_map
+                    .all_text_highlights()
+                    .map(|(key, highlights)| (*key, highlights.clone()))
+                    .collect::<Vec<_>>();
+                let semantic_token_highlights = display_map
+                    .all_semantic_token_highlights()
+                    .map(|(buffer_id, (tokens, interner))| {
+                        (*buffer_id, tokens.clone(), interner.clone())
+                    })
+                    .collect::<Vec<_>>();
+                (text_highlights, semantic_token_highlights)
+            });
 
-        let semantic_theme = cx.theme().syntax().clone();
-        display_map.update(cx, |display_map, cx| {
-            for (key, text_highlights) in display_map.all_text_highlights() {
-                for range in &text_highlights.1 {
-                    let Some((range_display, buffer_id, buffer_point_range)) =
-                        format_anchor_range(range, &multi_buffer_snapshot)
-                    else {
+        let mut semantic_highlights = Vec::new();
+        project.read(cx).lsp_store().update(cx, |lsp_store, cx| {
+            for (buffer_id, tokens, interner) in semantic_token_highlights {
+                let language_name = multi_buffer
+                    .read(cx)
+                    .buffer(buffer_id)
+                    .and_then(|buffer| buffer.read(cx).language().map(|language| language.name()));
+
+                for token in tokens.iter() {
+                    let Some(stylizer) = lsp_store.get_or_create_token_stylizer(
+                        token.server_id,
+                        language_name.as_ref(),
+                        cx,
+                    ) else {
                         continue;
                     };
-                    entries.push(HighlightEntry {
-                        range: range.clone(),
-                        buffer_id,
-                        range_display,
-                        style: text_highlights.0,
-                        category: HighlightCategory::Text(*key),
-                        buffer_point_range,
+
+                    let theme_key = stylizer
+                        .rules_for_token(token.token_type)
+                        .and_then(|rules| {
+                            rules
+                                .iter()
+                                .filter(|rule| {
+                                    rule.token_modifiers.iter().all(|modifier| {
+                                        stylizer.has_modifier(token.token_modifiers, modifier)
+                                    })
+                                })
+                                .fold(None, |theme_key, rule| {
+                                    rule.style
+                                        .iter()
+                                        .find(|style_name| {
+                                            syntax_theme.style_for_name(style_name).is_some()
+                                        })
+                                        .map(|style_name| SharedString::from(style_name.clone()))
+                                        .or(theme_key)
+                                })
+                        });
+
+                    semantic_highlights.push(SemanticHighlightEntry {
+                        range: token.range.start..token.range.end,
+                        style: interner[token.style],
+                        category: HighlightCategory::SemanticToken {
+                            token_type: stylizer.token_type_name(token.token_type).cloned(),
+                            token_modifiers: stylizer
+                                .token_modifiers(token.token_modifiers)
+                                .map(SharedString::from),
+                            theme_key,
+                        },
                     });
                 }
             }
-
-            project.read(cx).lsp_store().update(cx, |lsp_store, cx| {
-                for (buffer_id, (tokens, interner)) in display_map.all_semantic_token_highlights() {
-                    let language_name = multi_buffer
-                        .read(cx)
-                        .buffer(*buffer_id)
-                        .and_then(|buf| buf.read(cx).language().map(|l| l.name()));
-                    for token in tokens.iter() {
-                        let range = token.range.start..token.range.end;
-                        let Some((range_display, entry_buffer_id, buffer_point_range)) =
-                            format_anchor_range(&range, &multi_buffer_snapshot)
-                        else {
-                            continue;
-                        };
-                        let Some(stylizer) = lsp_store.get_or_create_token_stylizer(
-                            token.server_id,
-                            language_name.as_ref(),
-                            cx,
-                        ) else {
-                            continue;
-                        };
-
-                        let theme_key =
-                            stylizer
-                                .rules_for_token(token.token_type)
-                                .and_then(|rules| {
-                                    rules
-                                        .iter()
-                                        .filter(|rule| {
-                                            rule.token_modifiers.iter().all(|modifier| {
-                                                stylizer
-                                                    .has_modifier(token.token_modifiers, modifier)
-                                            })
-                                        })
-                                        .fold(None, |theme_key, rule| {
-                                            rule.style
-                                                .iter()
-                                                .find(|style_name| {
-                                                    semantic_theme
-                                                        .style_for_name(style_name)
-                                                        .is_some()
-                                                })
-                                                .map(|style_name| {
-                                                    SharedString::from(style_name.clone())
-                                                })
-                                                .or(theme_key)
-                                        })
-                                });
-
-                        entries.push(HighlightEntry {
-                            range,
-                            buffer_id: entry_buffer_id,
-                            range_display,
-                            style: interner[token.style],
-                            category: HighlightCategory::SemanticToken {
-                                token_type: stylizer.token_type_name(token.token_type).cloned(),
-                                token_modifiers: stylizer
-                                    .token_modifiers(token.token_modifiers)
-                                    .map(SharedString::from),
-                                theme_key,
-                            },
-                            buffer_point_range,
-                        });
-                    }
-                }
-            });
         });
 
-        let syntax_theme = cx.theme().syntax().clone();
-        for excerpt_range in multi_buffer_snapshot.excerpts() {
-            let Some(buffer_snapshot) =
-                multi_buffer_snapshot.buffer_for_id(excerpt_range.context.start.buffer_id)
-            else {
-                continue;
-            };
+        Some(HighlightRefreshInput {
+            multi_buffer_snapshot,
+            text_highlights,
+            semantic_highlights,
+            syntax_theme,
+        })
+    }
 
-            let start_offset = excerpt_range.context.start.to_offset(buffer_snapshot);
-            let end_offset = excerpt_range.context.end.to_offset(buffer_snapshot);
-            let range = start_offset..end_offset;
+    fn apply_highlight_refresh(
+        &mut self,
+        new_highlights: Vec<HighlightEntry>,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(editor) = self.editor.as_ref().map(|state| state.editor.clone()) else {
+            return;
+        };
+        let editor = editor.read(cx);
+        let cursor_position = editor.selections.newest_anchor().head();
+        let multi_buffer_snapshot = editor.buffer().read(cx).snapshot(cx);
 
-            let captures = buffer_snapshot.captures(range, |grammar| {
-                grammar.highlights_config.as_ref().map(|c| &c.query)
-            });
-            let grammars: Vec<_> = captures.grammars().to_vec();
-            let highlight_maps: Vec<_> = grammars.iter().map(|g| g.highlight_map()).collect();
-
-            for capture in captures {
-                let Some(highlight_id) = highlight_maps[capture.grammar_index].get(capture.index)
-                else {
-                    continue;
-                };
-                let Some(style) = syntax_theme.get(highlight_id).cloned() else {
-                    continue;
-                };
-
-                let theme_key = syntax_theme
-                    .get_capture_name(highlight_id)
-                    .map(|theme_key| SharedString::from(theme_key.to_string()));
-
-                let capture_name = grammars[capture.grammar_index]
-                    .highlights_config
-                    .as_ref()
-                    .and_then(|config| config.query.capture_names().get(capture.index as usize))
-                    .map(|capture_name| SharedString::from((*capture_name).to_string()))
-                    .unwrap_or_else(|| SharedString::from("unknown"));
-
-                let start_anchor = buffer_snapshot.anchor_before(capture.node.start_byte());
-                let end_anchor = buffer_snapshot.anchor_after(capture.node.end_byte());
-
-                let start = multi_buffer_snapshot.anchor_in_excerpt(start_anchor);
-                let end = multi_buffer_snapshot.anchor_in_excerpt(end_anchor);
-
-                let (start, end) = match (start, end) {
-                    (Some(s), Some(e)) => (s, e),
-                    _ => continue,
-                };
-
-                let range = start..end;
-                let Some((range_display, buffer_id, buffer_point_range)) =
-                    format_anchor_range(&range, &multi_buffer_snapshot)
-                else {
-                    continue;
-                };
-
-                entries.push(HighlightEntry {
-                    range,
-                    buffer_id,
-                    range_display,
-                    style,
-                    category: HighlightCategory::SyntaxToken {
-                        capture_name,
-                        theme_key,
-                    },
-                    buffer_point_range,
-                });
-            }
-        }
-
-        entries.sort_by(|a, b| {
-            a.buffer_id
-                .cmp(&b.buffer_id)
-                .then_with(|| a.buffer_point_range.start.cmp(&b.buffer_point_range.start))
-                .then_with(|| a.buffer_point_range.end.cmp(&b.buffer_point_range.end))
-                .then_with(|| a.category.cmp(&b.category))
-        });
-        entries.dedup_by(|a, b| {
-            a.buffer_id == b.buffer_id
-                && a.buffer_point_range == b.buffer_point_range
-                && a.category == b.category
-        });
-
-        self.cached_entries = entries;
+        self.is_singleton = multi_buffer_snapshot.is_singleton();
+        self.cached_entries = new_highlights;
+        self.hovered_item_ix = None;
         self.rebuild_display_items(&multi_buffer_snapshot, cx);
 
-        if self.skip_next_scroll {
-            self.skip_next_scroll = false;
-        } else {
-            self.scroll_to_cursor_position(&cursor_position, &multi_buffer_snapshot);
-        }
+        let should_scroll = !mem::take(&mut self.skip_next_scroll);
+        self.update_selection_for_cursor(&cursor_position, &multi_buffer_snapshot, should_scroll);
+        self.sync_editor_highlight_for_selected_entry(cx);
         cx.notify();
     }
 
     fn rebuild_display_items(&mut self, snapshot: &MultiBufferSnapshot, cx: &App) {
         self.display_items.clear();
 
-        let mut last_range_end: Option<Anchor> = None;
-
+        let mut last_range_end = None;
         for (entry_ix, entry) in self.cached_entries.iter().enumerate() {
             if !self.should_show_entry(entry) {
                 continue;
@@ -531,7 +479,47 @@ impl HighlightsTreeView {
         }
     }
 
-    fn scroll_to_cursor_position(&mut self, cursor: &Anchor, snapshot: &MultiBufferSnapshot) {
+    fn update_selection_from_editor(&mut self, cx: &mut Context<Self>) {
+        let Some(editor_state) = self.editor.as_ref() else {
+            return;
+        };
+
+        let (cursor_position, multi_buffer_snapshot) = {
+            let editor = editor_state.editor.read(cx);
+            (
+                editor.selections.newest_anchor().head(),
+                editor.buffer().read(cx).snapshot(cx),
+            )
+        };
+
+        let should_update_selection = !mem::take(&mut self.skip_next_scroll);
+        if !should_update_selection {
+            self.sync_editor_highlight_for_selected_entry(cx);
+            return;
+        }
+
+        let should_notify =
+            self.update_selection_for_cursor(&cursor_position, &multi_buffer_snapshot, true);
+        self.sync_editor_highlight_for_selected_entry(cx);
+        if should_notify {
+            cx.notify();
+        }
+    }
+
+    fn update_selection_for_cursor(
+        &mut self,
+        cursor: &Anchor,
+        snapshot: &MultiBufferSnapshot,
+        should_scroll: bool,
+    ) -> bool {
+        let cursor_point = cursor.to_point(snapshot);
+        let Some((cursor_buffer, cursor_point)) = snapshot.point_to_buffer_point(cursor_point)
+        else {
+            let changed = self.selected_item_ix.take().is_some();
+            return changed;
+        };
+        let cursor_buffer_id = cursor_buffer.remote_id();
+
         let best = self
             .display_items
             .iter()
@@ -544,12 +532,17 @@ impl HighlightsTreeView {
                 _ => None,
             })
             .filter(|(_, _, entry)| {
-                entry.range.start.cmp(&cursor, snapshot).is_le()
-                    && cursor.cmp(&entry.range.end, snapshot).is_lt()
+                entry.buffer_id == cursor_buffer_id
+                    && entry.buffer_point_range.start <= cursor_point
+                    && cursor_point < entry.buffer_point_range.end
             })
             .min_by_key(|(_, _, entry)| {
                 (
-                    entry.buffer_point_range.end.row - entry.buffer_point_range.start.row,
+                    entry
+                        .buffer_point_range
+                        .end
+                        .row
+                        .saturating_sub(entry.buffer_point_range.start.row),
                     entry
                         .buffer_point_range
                         .end
@@ -559,11 +552,17 @@ impl HighlightsTreeView {
             })
             .map(|(display_ix, entry_ix, _)| (display_ix, entry_ix));
 
-        if let Some((display_ix, entry_ix)) = best {
-            self.selected_item_ix = Some(entry_ix);
+        let selected_item_ix = best.map(|(_, entry_ix)| entry_ix);
+        let changed = self.selected_item_ix != selected_item_ix;
+        self.selected_item_ix = selected_item_ix;
+
+        if should_scroll && let Some((display_ix, _)) = best {
             self.list_scroll_handle
                 .scroll_to_item(display_ix, ScrollStrategy::Center);
+            return true;
         }
+
+        changed
     }
 
     fn update_editor_with_range_for_entry(
@@ -707,6 +706,25 @@ impl HighlightsTreeView {
         );
     }
 
+    fn sync_editor_highlight_for_selected_entry(&self, cx: &mut Context<Self>) {
+        let Some(editor_state) = self.editor.as_ref() else {
+            return;
+        };
+        let key = cx.entity_id().as_u64() as usize;
+        let range = self
+            .selected_item_ix
+            .and_then(|entry_ix| self.cached_entries.get(entry_ix))
+            .map(|entry| entry.range.clone());
+
+        editor_state.editor.update(cx, |editor, cx| {
+            if let Some(range) = range {
+                Self::set_editor_highlights(editor, key, &[range], cx);
+            } else {
+                editor.clear_background_highlights(HighlightKey::HighlightsTreeView(key), cx);
+            }
+        });
+    }
+
     fn clear_editor_highlights(editor: &Entity<Editor>, cx: &mut Context<Self>) {
         let highlight_key = HighlightKey::HighlightsTreeView(cx.entity_id().as_u64() as usize);
         editor.update(cx, |editor, cx| {
@@ -1105,6 +1123,142 @@ fn excerpt_label_for(
     path_label.into()
 }
 
+fn build_highlight_entries(
+    HighlightRefreshInput {
+        multi_buffer_snapshot,
+        text_highlights,
+        semantic_highlights,
+        syntax_theme,
+    }: HighlightRefreshInput,
+) -> Vec<HighlightEntry> {
+    let mut entries = Vec::new();
+
+    for (key, text_highlights) in text_highlights {
+        for range in &text_highlights.1 {
+            let Some((range_display, buffer_id, buffer_point_range)) =
+                format_anchor_range(range, &multi_buffer_snapshot)
+            else {
+                continue;
+            };
+            entries.push(HighlightEntry {
+                range: range.clone(),
+                buffer_id,
+                range_display,
+                style: text_highlights.0,
+                category: HighlightCategory::Text(key),
+                buffer_point_range,
+            });
+        }
+    }
+
+    for highlight in semantic_highlights {
+        let Some((range_display, buffer_id, buffer_point_range)) =
+            format_anchor_range(&highlight.range, &multi_buffer_snapshot)
+        else {
+            continue;
+        };
+
+        entries.push(HighlightEntry {
+            range: highlight.range,
+            buffer_id,
+            range_display,
+            style: highlight.style,
+            category: highlight.category,
+            buffer_point_range,
+        });
+    }
+
+    for excerpt_range in multi_buffer_snapshot.excerpts() {
+        let Some(buffer_snapshot) =
+            multi_buffer_snapshot.buffer_for_id(excerpt_range.context.start.buffer_id)
+        else {
+            continue;
+        };
+
+        let start_offset = excerpt_range.context.start.to_offset(buffer_snapshot);
+        let end_offset = excerpt_range.context.end.to_offset(buffer_snapshot);
+        let range = start_offset..end_offset;
+
+        let captures = buffer_snapshot.captures(range, |grammar| {
+            grammar
+                .highlights_config
+                .as_ref()
+                .map(|config| &config.query)
+        });
+        let grammars = captures.grammars().to_vec();
+        let highlight_maps = grammars
+            .iter()
+            .map(|grammar| grammar.highlight_map())
+            .collect::<Vec<_>>();
+
+        for capture in captures {
+            let Some(highlight_id) = highlight_maps[capture.grammar_index].get(capture.index)
+            else {
+                continue;
+            };
+            let Some(style) = syntax_theme.get(highlight_id).cloned() else {
+                continue;
+            };
+
+            let theme_key = syntax_theme
+                .get_capture_name(highlight_id)
+                .map(|theme_key| SharedString::from(theme_key.to_string()));
+
+            let capture_name = grammars[capture.grammar_index]
+                .highlights_config
+                .as_ref()
+                .and_then(|config| config.query.capture_names().get(capture.index as usize))
+                .map(|capture_name| SharedString::from((*capture_name).to_string()))
+                .unwrap_or_else(|| SharedString::from("unknown"));
+
+            let start_anchor = buffer_snapshot.anchor_before(capture.node.start_byte());
+            let end_anchor = buffer_snapshot.anchor_after(capture.node.end_byte());
+
+            let start = multi_buffer_snapshot.anchor_in_excerpt(start_anchor);
+            let end = multi_buffer_snapshot.anchor_in_excerpt(end_anchor);
+
+            let (start, end) = match (start, end) {
+                (Some(start), Some(end)) => (start, end),
+                _ => continue,
+            };
+
+            let range = start..end;
+            let Some((range_display, buffer_id, buffer_point_range)) =
+                format_anchor_range(&range, &multi_buffer_snapshot)
+            else {
+                continue;
+            };
+
+            entries.push(HighlightEntry {
+                range,
+                buffer_id,
+                range_display,
+                style,
+                category: HighlightCategory::SyntaxToken {
+                    capture_name,
+                    theme_key,
+                },
+                buffer_point_range,
+            });
+        }
+    }
+
+    entries.sort_by(|a, b| {
+        a.buffer_id
+            .cmp(&b.buffer_id)
+            .then_with(|| a.buffer_point_range.start.cmp(&b.buffer_point_range.start))
+            .then_with(|| a.buffer_point_range.end.cmp(&b.buffer_point_range.end))
+            .then_with(|| a.category.cmp(&b.category))
+    });
+    entries.dedup_by(|a, b| {
+        a.buffer_id == b.buffer_id
+            && a.buffer_point_range == b.buffer_point_range
+            && a.category == b.category
+    });
+
+    entries
+}
+
 fn format_anchor_range(
     range: &Range<Anchor>,
     snapshot: &MultiBufferSnapshot,

From 3a81f8e9ab80c241300467d28267dd5eafb80eb5 Mon Sep 17 00:00:00 2001
From: "zed-zippy[bot]" <234243425+zed-zippy[bot]@users.noreply.github.com>
Date: Wed, 20 May 2026 10:45:29 -0400
Subject: [PATCH 065/105] Bump Zed to v1.5.0 (#57272)

Release Notes:

- N/A

Co-authored-by: zed-zippy[bot] <234243425+zed-zippy[bot]@users.noreply.github.com>
---
 Cargo.lock            | 2 +-
 crates/zed/Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 60b7b291ae5..a8a9bb1c79e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -22476,7 +22476,7 @@ dependencies = [
 
 [[package]]
 name = "zed"
-version = "1.4.0"
+version = "1.5.0"
 dependencies = [
  "acp_thread",
  "acp_tools",
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index d0b5227afb1..79bb5cca724 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -2,7 +2,7 @@
 description = "The fast, collaborative code editor."
 edition.workspace = true
 name = "zed"
-version = "1.4.0"
+version = "1.5.0"
 publish.workspace = true
 license = "GPL-3.0-or-later"
 authors = ["Zed Team <hi@zed.dev>"]

From bb63046a085556b5f0e169cd51a433a2723f41ab Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mar=C3=ADa=20Craig?= <maria@zed.dev>
Date: Wed, 20 May 2026 12:34:06 -0300
Subject: [PATCH 066/105] docs: Add Skills settings documentation (#57273)

Adds documentation for the Skills settings UI introduced alongside the
Skills feature.

## Changes

- **Updated** `docs/src/ai/skills.md`:
- Updated "Create your own" to lead with `/create-skill` and mention the
Skill Creator UI as a secondary option
- Added "Managing Skills" section documenting the Settings Editor Skills
page (view, open, delete skills)

Release Notes:

- N/A
---
 docs/src/ai/skills.md | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/docs/src/ai/skills.md b/docs/src/ai/skills.md
index 25ffebc9728..73d8712b44f 100644
--- a/docs/src/ai/skills.md
+++ b/docs/src/ai/skills.md
@@ -11,11 +11,13 @@ A skill is a folder containing a `SKILL.md` file with metadata and instructions.
 
 ## Adding Skills {#adding-skills}
 
-### Create Your Own {#create-your-own}
+### Create your own {#create-your-own}
 
-Zed includes a built-in `create-skill` skill that guides the agent through creating a new skill. Invoke it with `/create-skill`, or let the agent pick it up automatically when you ask it to help create a skill.
+Zed includes a built-in `create-skill` skill — invoke it with `/create-skill` and the agent walks you through the process.
 
-See [Skill format](#skill-format) below for the folder structure and `SKILL.md` reference.
+You can also open the Skill Creator directly with the {#action agent::OpenSkillCreator} action. It opens a window where you fill in the skill's name, description, scope (global or project-local), body, and optionally toggle `disable-model-invocation`.
+
+See [Skill format](#skill-format) below for the full format reference.
 
 ### From the skills.sh Registry {#from-the-registry}
 
@@ -38,6 +40,19 @@ git sparse-checkout set frontend-design
 
 For a project-local install, do the same inside your project's `.agents/skills/` folder.
 
+## Managing Skills {#managing-skills}
+
+Open the Settings Editor (`Cmd+,` on macOS, `Ctrl+,` on Linux/Windows) and navigate to **AI > Skills**, or go directly to [agent.skills](zed://settings/agent.skills).
+
+The **User** tab shows your global skills. The **Project** tab shows skills for the current project.
+
+For each skill you can:
+
+- **Open** — opens the skill's `SKILL.md` file in the editor
+- **Delete** — removes the skill folder from disk
+
+If no skills are installed, the page shows a **Create a Skill** button that opens the Skill Creator.
+
 ## Using Skills {#using-skills}
 
 By default, the agent picks up skills autonomously. It sees a catalog of every installed skill (name and description) in its system prompt, and calls the `skill` tool when a task matches a skill's description.

From d2953a2b57cd94402dad5fcf20746d8241ada00f Mon Sep 17 00:00:00 2001
From: liam <liam@scalzulli.com>
Date: Wed, 20 May 2026 12:03:16 -0400
Subject: [PATCH 067/105] Hide agent actions in embedded terminal menus
 (#56256)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Resolves https://github.com/zed-industries/zed/issues/56138

This diff hides terminal agent actions from context menus shown by
embedded terminal views, such as terminal tool output in agent threads.
Those surfaces render through `TerminalView`, but they are not normal
interactive terminal panes, and actions like Inline Assist and Add to
Agent Thread do not currently resolve the embedded terminal as their
target.

Previously, choosing Inline Assist from terminal tool output could
target the workspace’s active editor instead of the terminal output. The
context menu now limits these agent actions to non-embedded terminal
views, so regular terminal panes keep their existing behavior while
terminal tool output no longer offers actions that cannot resolve to it.

Add to Agent Thread _could_ make sense for embedded terminal selections
in the future, but it would need explicit target-resolution support for
focused embedded terminals. This change keeps that as separate follow-up
work instead of leaving a misleading menu item that does not reliably
act on the selected tool output.

Release Notes:
- Fixed embedded terminal context menus showing agent actions that could
target the wrong item.
---
 crates/terminal_view/src/terminal_view.rs | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/crates/terminal_view/src/terminal_view.rs b/crates/terminal_view/src/terminal_view.rs
index 55e6929d832..cc0430bf853 100644
--- a/crates/terminal_view/src/terminal_view.rs
+++ b/crates/terminal_view/src/terminal_view.rs
@@ -513,13 +513,16 @@ impl TerminalView {
                 .action("Paste Text", Box::new(PasteText))
                 .action("Select All", Box::new(SelectAll))
                 .action("Clear", Box::new(Clear))
-                .when(assistant_enabled, |menu| {
-                    menu.separator()
-                        .action("Inline Assist", Box::new(InlineAssist::default()))
-                        .when(has_selection, |menu| {
-                            menu.action("Add to Agent Thread", Box::new(AddSelectionToThread))
-                        })
-                })
+                .when(
+                    assistant_enabled && !matches!(self.mode, TerminalMode::Embedded { .. }),
+                    |menu| {
+                        menu.separator()
+                            .action("Inline Assist", Box::new(InlineAssist::default()))
+                            .when(has_selection, |menu| {
+                                menu.action("Add to Agent Thread", Box::new(AddSelectionToThread))
+                            })
+                    },
+                )
                 .separator()
                 .action(
                     "Close Terminal Tab",

From 814443a466b92f9c5fea09265198f3ffb7bd93ce Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mar=C3=ADa=20Craig?= <maria@zed.dev>
Date: Wed, 20 May 2026 14:54:47 -0300
Subject: [PATCH 068/105] docs: Fix skill installation instructions (#57289)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fixes the skill installation instructions in `docs/src/ai/skills.md`.

The previous steps used a `git sparse-checkout` approach that was
inaccurate — the cloned repo would land nested inside the skills folder,
and the sparse-checkout path was wrong for repos that store skills in a
subdirectory. Replaced with a simple instruction to copy the skill's
folder into the appropriate location.

Release Notes:

- N/A
---
 docs/src/ai/skills.md | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/docs/src/ai/skills.md b/docs/src/ai/skills.md
index 73d8712b44f..bd2d905b830 100644
--- a/docs/src/ai/skills.md
+++ b/docs/src/ai/skills.md
@@ -27,18 +27,20 @@ See [Skill format](#skill-format) below for the full format reference.
 - [`frontend-design`](https://skills.sh/anthropics/skills/frontend-design): production-grade frontend interfaces with design polish
 - [`pdf`](https://skills.sh/anthropics/skills/pdf): PDF text extraction, merging, splitting, form filling, and OCR
 
-To install a skill from it, copy or clone its folder into your global or project-local skills folder.
+To install a skill, copy the skill's folder into `~/.agents/skills/` for global use, or into your project's `.agents/skills/` folder for project-local use.
 
-For example, to install the `frontend-design` skill from GitHub globally:
+## Managing Skills {#managing-skills}
 
-```sh
-cd ~/.agents/skills
-git clone --filter=blob:none --sparse https://github.com/anthropics/skills
-cd skills
-git sparse-checkout set frontend-design
-```
+Open the Settings Editor (`Cmd+,` on macOS, `Ctrl+,` on Linux/Windows) and navigate to **AI > Skills**, or go directly to [agent.skills](zed://settings/agent.skills).
 
-For a project-local install, do the same inside your project's `.agents/skills/` folder.
+The **User** tab shows your global skills. The **Project** tab shows skills for the current project.
+
+For each skill you can:
+
+- **Open** — opens the skill's `SKILL.md` file in the editor
+- **Delete** — removes the skill folder from disk
+
+If no skills are installed, the page shows a **Create a Skill** button that opens the Skill Creator.
 
 ## Managing Skills {#managing-skills}
 

From c7b9039e4b7f0f975a7d25a6339590005ea98dfa Mon Sep 17 00:00:00 2001
From: Richard Feldman <richard@zed.dev>
Date: Wed, 20 May 2026 15:43:07 -0400
Subject: [PATCH 069/105] Add runtime diagnostics to git job queue debug dump
 (#57294)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds a `runtime_diagnostics` section to the dev-only "Show Git Job
Queue" output so that when the queue gets stuck, we can tell from the
dump itself whether a git subprocess is wedged (and on supported
platforms, where it's wedged) without needing the user to run
`ps`/`sample`/`lsof` by hand.

The new section contains:

- **`processes`** — every transitive descendant of the Zed process, with
PID, PPID, name, executable, full argv, sysinfo status
(`Run`/`Sleep`/`Stop`/`Zombie`/etc.), and elapsed runtime.
Cross-platform via `sysinfo`. This is the single most useful field: it
instantly answers "is there a stuck `git` child or not?"
- **`linux_proc`** *(Linux only)* — for each descendant,
`/proc/<pid>/wchan` (the kernel function the thread is sleeping in, e.g.
`futex_wait_queue`, `pipe_read`) and `State:` from `/proc/<pid>/status`.
- **`macos_git_children`** *(macOS only)* — for any descendant whose
name contains `git`, a 2-second `sample` user-space stack and `lsof -p`
output. Each is included only if the corresponding system binary exists;
otherwise it's skipped.
- Windows gets just `processes` (no portable way to grab another
process's stack).

### Safety

- Cross-platform: only `sysinfo` (an existing workspace dep) is on the
always-compiled path. All `sample`/`lsof`/`/proc` code is behind
`#[cfg(target_os = ...)]` gates, so Windows builds never see those
symbols.
- Every fallible step is handled individually: on error it logs a
warning and the corresponding key is omitted from the JSON. The queue
dump is built and shown the same way whether `gather()` returned a
populated object, an empty object, or partial data.
- Diagnostics gather runs under `cx.background_spawn(...)` so the macOS
`sample` 2-second wait can't block the foreground.
- `sample`/`lsof` output is truncated to 64 KB per process at a UTF-8
char boundary.

Release Notes:

- N/A
---
 Cargo.lock                                    |   1 +
 crates/git_ui/Cargo.toml                      |   1 +
 crates/git_ui/src/git_panel.rs                |  23 +-
 crates/git_ui/src/git_runtime_diagnostics.rs  | 415 ++++++++++++++++++
 crates/git_ui/src/git_ui.rs                   |   1 +
 .../project/src/git_store/job_debug_queue.rs  |  10 +-
 6 files changed, 446 insertions(+), 5 deletions(-)
 create mode 100644 crates/git_ui/src/git_runtime_diagnostics.rs

diff --git a/Cargo.lock b/Cargo.lock
index a8a9bb1c79e..ad760e911e2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7461,6 +7461,7 @@ dependencies = [
  "settings",
  "smallvec",
  "strum 0.27.2",
+ "sysinfo 0.37.2",
  "task",
  "telemetry",
  "theme",
diff --git a/crates/git_ui/Cargo.toml b/crates/git_ui/Cargo.toml
index 19242ee3f05..348f41371e6 100644
--- a/crates/git_ui/Cargo.toml
+++ b/crates/git_ui/Cargo.toml
@@ -57,6 +57,7 @@ serde_json.workspace = true
 settings.workspace = true
 smallvec.workspace = true
 strum.workspace = true
+sysinfo.workspace = true
 telemetry.workspace = true
 theme.workspace = true
 theme_settings.workspace = true
diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs
index 04246fcd645..1eee2d818b0 100644
--- a/crates/git_ui/src/git_panel.rs
+++ b/crates/git_ui/src/git_panel.rs
@@ -3955,7 +3955,7 @@ impl GitPanel {
         };
 
         let repo_path = repo.read(cx).work_directory_abs_path.display().to_string();
-        let text = repo.read(cx).job_debug_queue().to_debug_string();
+        let queue_value = repo.read(cx).job_debug_queue().to_debug_value();
         let title = format!("Git Job Queue: {repo_path}");
 
         let json_language = self.project.read(cx).languages().language_for_name("JSON");
@@ -3966,6 +3966,27 @@ impl GitPanel {
             .spawn(cx, async move |cx| {
                 let json_language = json_language.await.ok();
 
+                // Best-effort: gather runtime diagnostics off the main thread.
+                // Any failure inside `gather` is logged and produces an empty
+                // section; this `.await` itself cannot meaningfully fail and
+                // must never prevent us from showing the queue dump.
+                let diagnostics = cx
+                    .background_spawn(crate::git_runtime_diagnostics::gather())
+                    .await;
+
+                let mut combined = queue_value;
+                if let serde_json::Value::Object(ref mut map) = combined
+                    && let serde_json::Value::Object(diag_map) = diagnostics
+                    && !diag_map.is_empty()
+                {
+                    map.insert(
+                        "runtime_diagnostics".into(),
+                        serde_json::Value::Object(diag_map),
+                    );
+                }
+
+                let text = serde_json::to_string_pretty(&combined).unwrap_or_default();
+
                 let buffer = project
                     .update(cx, |project, cx| {
                         project.create_buffer(json_language, false, cx)
diff --git a/crates/git_ui/src/git_runtime_diagnostics.rs b/crates/git_ui/src/git_runtime_diagnostics.rs
new file mode 100644
index 00000000000..8377848fb22
--- /dev/null
+++ b/crates/git_ui/src/git_runtime_diagnostics.rs
@@ -0,0 +1,415 @@
+//! Best-effort runtime diagnostics gathered to accompany the git job queue
+//! debug dump. Every individual step is fallible and any failure is logged at
+//! `warn` level and silently omitted from the output. The dump itself must
+//! never fail just because diagnostics couldn't be collected.
+//!
+//! What we gather:
+//! - All transitive descendant processes of the current Zed process
+//!   (cross-platform via `sysinfo`).
+//! - On Linux: each descendant's `/proc/<pid>/wchan` (kernel function the
+//!   thread is currently sleeping in) and `State:` from `/proc/<pid>/status`.
+//! - On macOS: for any descendant whose executable name contains `git`, a
+//!   short `sample`-based user-space stack and `lsof` output. Both require
+//!   the corresponding system binaries; if they aren't present or the
+//!   invocation fails we skip them.
+//! - On Windows: just the process tree (no portable way to grab another
+//!   process's stack).
+//!
+//! The output is a `serde_json::Value`. Callers merge it into whatever larger
+//! JSON payload they're producing.
+//!
+//! This is invoked from a developer-only "show git job queue" action, so it
+//! is acceptable for the macOS path to spend a few seconds sampling.
+
+use serde_json::{Map, Value};
+
+pub async fn gather() -> Value {
+    let mut diag = Map::new();
+
+    match collect_process_tree() {
+        Ok(tree) => {
+            diag.insert("processes".into(), tree);
+        }
+        Err(err) => {
+            log::warn!("git runtime diagnostics: failed to collect process tree: {err:#}");
+        }
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+        match collect_linux_proc_info() {
+            Ok(info) => {
+                diag.insert("linux_proc".into(), info);
+            }
+            Err(err) => {
+                log::warn!("git runtime diagnostics: failed to read /proc info: {err:#}");
+            }
+        }
+    }
+
+    #[cfg(target_os = "macos")]
+    {
+        match collect_macos_git_child_diagnostics().await {
+            Ok(info) => {
+                if !info.is_null() {
+                    diag.insert("macos_git_children".into(), info);
+                }
+            }
+            Err(err) => {
+                log::warn!(
+                    "git runtime diagnostics: failed to collect macOS git-child info: {err:#}"
+                );
+            }
+        }
+    }
+
+    Value::Object(diag)
+}
+
+/// Walk the descendant tree of the current process and return a JSON array
+/// describing each descendant. Cross-platform; uses `sysinfo`.
+fn collect_process_tree() -> anyhow::Result<Value> {
+    use sysinfo::{ProcessRefreshKind, ProcessesToUpdate, RefreshKind, System, UpdateKind};
+
+    let current_pid = sysinfo::get_current_pid()
+        .map_err(|e| anyhow::anyhow!("sysinfo::get_current_pid failed: {e}"))?;
+
+    let refresh = ProcessRefreshKind::nothing()
+        .with_cmd(UpdateKind::Always)
+        .with_exe(UpdateKind::Always);
+    let mut system = System::new_with_specifics(RefreshKind::nothing().with_processes(refresh));
+    system.refresh_processes_specifics(ProcessesToUpdate::All, true, refresh);
+
+    let descendants = descendants_of(&system, current_pid);
+
+    let entries: Vec<Value> = descendants
+        .iter()
+        .filter_map(|pid| {
+            let process = system.process(*pid)?;
+            let cmd = sanitize_cmd(
+                process
+                    .cmd()
+                    .iter()
+                    .map(|s| s.to_string_lossy().into_owned()),
+            );
+            Some(serde_json::json!({
+                "pid": pid.as_u32(),
+                "ppid": process.parent().map(|p| p.as_u32()),
+                "name": process.name().to_string_lossy(),
+                "exe": process.exe().map(|p| p.display().to_string()),
+                "cmd": cmd,
+                "status": format!("{:?}", process.status()),
+                "run_time_secs": process.run_time(),
+            }))
+        })
+        .collect();
+
+    Ok(serde_json::json!({
+        "zed_pid": current_pid.as_u32(),
+        "descendant_count": entries.len(),
+        "descendants": entries,
+    }))
+}
+
+/// Scrub a process's reported argv to avoid leaking environment-variable
+/// values. sysinfo's `Process::cmd()` on macOS goes through `KERN_PROCARGS2`
+/// and can include envp in addition to argv for some processes, which means
+/// the raw output can contain things like `ANTHROPIC_API_KEY=…`. We replace
+/// any entry that matches a conservative env-var pattern (uppercase
+/// identifier ending in `=`) with `KEY=<redacted>`. If *every* entry got
+/// redacted then sysinfo's data for this process is too garbled to trust as
+/// argv, so we return `None` so the caller emits a JSON null rather than
+/// something misleading.
+fn sanitize_cmd(cmd: impl IntoIterator<Item = String>) -> Option<Vec<String>> {
+    let sanitized: Vec<String> = cmd.into_iter().map(redact_env_var_entry).collect();
+    if sanitized.is_empty() {
+        return None;
+    }
+    let all_redacted = sanitized.iter().all(|s| s.ends_with("=<redacted>"));
+    if all_redacted { None } else { Some(sanitized) }
+}
+
+fn redact_env_var_entry(entry: String) -> String {
+    // Match `IDENT=...` where IDENT is at least two characters starting with
+    // an uppercase letter or underscore and otherwise uppercase/digit/under.
+    // CLI flags (`--foo=bar`, `-x=y`, `/path=value`) don't match.
+    let Some(eq_index) = entry.find('=') else {
+        return entry;
+    };
+    let key = &entry[..eq_index];
+    if !key.is_empty()
+        && key
+            .chars()
+            .all(|c| c.is_ascii_uppercase() || c.is_ascii_digit() || c == '_')
+        && key.starts_with(|c: char| c.is_ascii_uppercase() || c == '_')
+    {
+        format!("{key}=<redacted>")
+    } else {
+        entry
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[track_caller]
+    fn assert_redacts(input: &str, expected: &str) {
+        assert_eq!(redact_env_var_entry(input.to_string()), expected);
+    }
+
+    #[test]
+    fn redacts_secret_looking_env_vars() {
+        assert_redacts(
+            "ANTHROPIC_API_KEY=sk-ant-api03-abcdef",
+            "ANTHROPIC_API_KEY=<redacted>",
+        );
+        assert_redacts(
+            "AWS_SECRET_ACCESS_KEY=anything-at-all",
+            "AWS_SECRET_ACCESS_KEY=<redacted>",
+        );
+        assert_redacts("PATH=/usr/bin:/bin", "PATH=<redacted>");
+        assert_redacts("A=1", "A=<redacted>");
+        assert_redacts("_FOO=bar", "_FOO=<redacted>");
+        // Values may legitimately contain `=`; only the value portion is dropped.
+        assert_redacts("TOKEN=abc=def=ghi", "TOKEN=<redacted>");
+        // Empty value still redacts (and importantly, doesn't pretend to be a flag).
+        assert_redacts("PASSWORD=", "PASSWORD=<redacted>");
+    }
+
+    #[test]
+    fn leaves_real_argv_alone() {
+        // CLI flags that happen to contain `=`.
+        assert_redacts("--max-old-space-size=8092", "--max-old-space-size=8092");
+        assert_redacts("-Dfoo=bar", "-Dfoo=bar");
+        // Paths.
+        assert_redacts("/opt/homebrew/bin/node", "/opt/homebrew/bin/node");
+        // Bare strings without `=`.
+        assert_redacts("--cancellationPipeName", "--cancellationPipeName");
+        assert_redacts(
+            "npm exec mcp-remote https://example.com",
+            "npm exec mcp-remote https://example.com",
+        );
+        // Lowercase / mixed-case identifiers aren't env vars by convention; leave them.
+        assert_redacts("foo=bar", "foo=bar");
+        assert_redacts("camelCase=value", "camelCase=value");
+        // Pathological: `=value` with no key.
+        assert_redacts("=value", "=value");
+    }
+
+    #[test]
+    fn sanitize_returns_none_when_everything_redacted() {
+        let cmd = vec![
+            "FOO=1".to_string(),
+            "BAR=2".to_string(),
+            "ANTHROPIC_API_KEY=secret".to_string(),
+        ];
+        assert_eq!(sanitize_cmd(cmd), None);
+    }
+
+    #[test]
+    fn sanitize_preserves_real_argv_and_redacts_env_vars() {
+        // The exact pattern observed in a real diagnostic dump.
+        let cmd = vec![
+            "npm exec mcp-remote https://mcp.linear.app/mcp".to_string(),
+            "ALACRITTY_WINDOW_ID=38654706047".to_string(),
+            "AMP_FORCE_BEL=1".to_string(),
+            "ANTHROPIC_API_KEY=sk-ant-api03-realsecret".to_string(),
+        ];
+        assert_eq!(
+            sanitize_cmd(cmd),
+            Some(vec![
+                "npm exec mcp-remote https://mcp.linear.app/mcp".to_string(),
+                "ALACRITTY_WINDOW_ID=<redacted>".to_string(),
+                "AMP_FORCE_BEL=<redacted>".to_string(),
+                "ANTHROPIC_API_KEY=<redacted>".to_string(),
+            ])
+        );
+    }
+
+    #[test]
+    fn sanitize_handles_empty_cmd() {
+        let cmd: Vec<String> = Vec::new();
+        assert_eq!(sanitize_cmd(cmd), None);
+    }
+}
+
+fn descendants_of(system: &sysinfo::System, root: sysinfo::Pid) -> Vec<sysinfo::Pid> {
+    let mut parent_map: std::collections::HashMap<sysinfo::Pid, Vec<sysinfo::Pid>> =
+        std::collections::HashMap::new();
+    for (pid, process) in system.processes() {
+        if let Some(parent) = process.parent() {
+            parent_map.entry(parent).or_default().push(*pid);
+        }
+    }
+    let mut out = Vec::new();
+    let mut stack = vec![root];
+    while let Some(p) = stack.pop() {
+        if let Some(children) = parent_map.get(&p) {
+            for c in children {
+                out.push(*c);
+                stack.push(*c);
+            }
+        }
+    }
+    out
+}
+
+#[cfg(target_os = "linux")]
+fn collect_linux_proc_info() -> anyhow::Result<Value> {
+    use sysinfo::{ProcessRefreshKind, ProcessesToUpdate, RefreshKind, System};
+
+    let current_pid = sysinfo::get_current_pid()
+        .map_err(|e| anyhow::anyhow!("sysinfo::get_current_pid failed: {e}"))?;
+    let refresh = ProcessRefreshKind::nothing();
+    let mut system = System::new_with_specifics(RefreshKind::nothing().with_processes(refresh));
+    system.refresh_processes_specifics(ProcessesToUpdate::All, true, refresh);
+
+    let descendants = descendants_of(&system, current_pid);
+
+    let mut entries = Vec::new();
+    for pid in descendants {
+        let pid_u32 = pid.as_u32();
+
+        let wchan = match std::fs::read_to_string(format!("/proc/{pid_u32}/wchan")) {
+            Ok(s) => Value::String(s.trim().to_string()),
+            Err(err) => {
+                log::warn!("git runtime diagnostics: failed to read /proc/{pid_u32}/wchan: {err}");
+                Value::Null
+            }
+        };
+
+        let state = match std::fs::read_to_string(format!("/proc/{pid_u32}/status")) {
+            Ok(contents) => contents
+                .lines()
+                .find(|l| l.starts_with("State:"))
+                .map(|l| Value::String(l.trim_start_matches("State:").trim().to_string()))
+                .unwrap_or(Value::Null),
+            Err(err) => {
+                log::warn!("git runtime diagnostics: failed to read /proc/{pid_u32}/status: {err}");
+                Value::Null
+            }
+        };
+
+        entries.push(serde_json::json!({
+            "pid": pid_u32,
+            "wchan": wchan,
+            "state": state,
+        }));
+    }
+
+    Ok(serde_json::json!({ "descendants": entries }))
+}
+
+#[cfg(target_os = "macos")]
+async fn collect_macos_git_child_diagnostics() -> anyhow::Result<Value> {
+    use std::path::Path;
+    use sysinfo::{ProcessRefreshKind, ProcessesToUpdate, RefreshKind, System, UpdateKind};
+
+    let sample_available = Path::new("/usr/bin/sample").exists();
+    let lsof_available =
+        Path::new("/usr/sbin/lsof").exists() || Path::new("/usr/bin/lsof").exists();
+    let lsof_path = if Path::new("/usr/sbin/lsof").exists() {
+        "/usr/sbin/lsof"
+    } else {
+        "/usr/bin/lsof"
+    };
+
+    if !sample_available && !lsof_available {
+        return Ok(Value::Null);
+    }
+
+    let current_pid = sysinfo::get_current_pid()
+        .map_err(|e| anyhow::anyhow!("sysinfo::get_current_pid failed: {e}"))?;
+
+    let refresh = ProcessRefreshKind::nothing().with_exe(UpdateKind::Always);
+    let mut system = System::new_with_specifics(RefreshKind::nothing().with_processes(refresh));
+    system.refresh_processes_specifics(ProcessesToUpdate::All, true, refresh);
+
+    let descendants = descendants_of(&system, current_pid);
+
+    // Limit ourselves to git-flavored descendants. We don't want to spend
+    // several seconds sampling unrelated children (terminals, language
+    // servers, etc.). Match by name containing "git" — covers `git`,
+    // `git-remote-https`, `git-credential-osxkeychain`, hook subprocesses
+    // named with `git` in them, etc.
+    let git_descendants: Vec<u32> = descendants
+        .iter()
+        .filter_map(|pid| {
+            let process = system.process(*pid)?;
+            let name = process.name().to_string_lossy();
+            if name.contains("git") {
+                Some(pid.as_u32())
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    if git_descendants.is_empty() {
+        return Ok(Value::Null);
+    }
+
+    let mut entries = Vec::new();
+    for pid in git_descendants {
+        let mut entry = Map::new();
+        entry.insert("pid".into(), Value::from(pid));
+
+        if sample_available {
+            match run_capturing("/usr/bin/sample", &[&pid.to_string(), "2", "-mayDie"]).await {
+                Ok(output) => {
+                    entry.insert("sample".into(), Value::String(truncate(output, 64 * 1024)));
+                }
+                Err(err) => {
+                    log::warn!("git runtime diagnostics: `sample {pid}` failed: {err}");
+                }
+            }
+        }
+
+        if lsof_available {
+            match run_capturing(lsof_path, &["-p", &pid.to_string()]).await {
+                Ok(output) => {
+                    entry.insert("lsof".into(), Value::String(truncate(output, 64 * 1024)));
+                }
+                Err(err) => {
+                    log::warn!("git runtime diagnostics: `lsof -p {pid}` failed: {err}");
+                }
+            }
+        }
+
+        entries.push(Value::Object(entry));
+    }
+
+    Ok(Value::Array(entries))
+}
+
+#[cfg(target_os = "macos")]
+async fn run_capturing(program: &str, args: &[&str]) -> anyhow::Result<String> {
+    let output = util::command::new_command(program)
+        .args(args)
+        .output()
+        .await?;
+    if !output.status.success() {
+        anyhow::bail!(
+            "{program} exited with status {:?}: {}",
+            output.status,
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+    Ok(String::from_utf8_lossy(&output.stdout).into_owned())
+}
+
+#[cfg(target_os = "macos")]
+fn truncate(mut s: String, max_bytes: usize) -> String {
+    if s.len() <= max_bytes {
+        return s;
+    }
+    // Find a UTF-8 char boundary at or before `max_bytes`.
+    let mut cut = max_bytes;
+    while cut > 0 && !s.is_char_boundary(cut) {
+        cut -= 1;
+    }
+    s.truncate(cut);
+    s.push_str("\n…(truncated)");
+    s
+}
diff --git a/crates/git_ui/src/git_ui.rs b/crates/git_ui/src/git_ui.rs
index 4fda322cc89..f791ade8e0c 100644
--- a/crates/git_ui/src/git_ui.rs
+++ b/crates/git_ui/src/git_ui.rs
@@ -39,6 +39,7 @@ pub mod file_diff_view;
 pub mod git_panel;
 mod git_panel_settings;
 pub mod git_picker;
+mod git_runtime_diagnostics;
 pub mod multi_diff_view;
 pub mod picker_prompt;
 pub mod project_diff;
diff --git a/crates/project/src/git_store/job_debug_queue.rs b/crates/project/src/git_store/job_debug_queue.rs
index c204451d58b..6a31e62b02c 100644
--- a/crates/project/src/git_store/job_debug_queue.rs
+++ b/crates/project/src/git_store/job_debug_queue.rs
@@ -113,6 +113,10 @@ impl GitJobDebugQueue {
     }
 
     pub fn to_debug_string(&self) -> String {
+        serde_json::to_string_pretty(&self.to_debug_value()).unwrap_or_default()
+    }
+
+    pub fn to_debug_value(&self) -> serde_json::Value {
         let mut entries = Vec::new();
 
         let mut pending_count = 0u64;
@@ -141,7 +145,7 @@ impl GitJobDebugQueue {
         let json_entries: Vec<serde_json::Value> =
             entries.into_iter().map(|(_, json)| json).collect();
 
-        let json = serde_json::json!({
+        serde_json::json!({
             "summary": {
                 "pending": pending_count,
                 "running": running_count,
@@ -149,9 +153,7 @@ impl GitJobDebugQueue {
                 "skipped": skipped_count,
             },
             "entries": json_entries,
-        });
-
-        serde_json::to_string_pretty(&json).unwrap_or_default()
+        })
     }
 
     fn format_pending(&self, job: &PendingJob) -> serde_json::Value {

From 2b506483b282d5c6b22dfea7b83e05632e78e3ab Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mar=C3=ADa=20Craig?= <maria@zed.dev>
Date: Wed, 20 May 2026 17:42:25 -0300
Subject: [PATCH 070/105] docs: Document how to open the Skill Creator (#57314)

Documents the ways to open the Skill Creator in `docs/src/ai/skills.md`:

- From the Agent Panel using the keybinding ({#kb
agent::OpenRulesLibrary})
- From the Agent Panel `...` menu > **Skills**
- From the command palette via {#action agent::OpenSkillCreator}

Release Notes:

- N/A
---
 docs/src/ai/skills.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/src/ai/skills.md b/docs/src/ai/skills.md
index bd2d905b830..2662b33e160 100644
--- a/docs/src/ai/skills.md
+++ b/docs/src/ai/skills.md
@@ -15,7 +15,7 @@ A skill is a folder containing a `SKILL.md` file with metadata and instructions.
 
 Zed includes a built-in `create-skill` skill — invoke it with `/create-skill` and the agent walks you through the process.
 
-You can also open the Skill Creator directly with the {#action agent::OpenSkillCreator} action. It opens a window where you fill in the skill's name, description, scope (global or project-local), body, and optionally toggle `disable-model-invocation`.
+You can also open the Skill Creator from the Agent Panel using {#kb agent::OpenRulesLibrary}, or by clicking `...` and selecting **Skills**. Outside the panel, use the {#action agent::OpenSkillCreator} action from the command palette. It opens a window where you fill in the skill's name, description, scope (global or project-local), body, and optionally toggle `disable-model-invocation`.
 
 See [Skill format](#skill-format) below for the full format reference.
 

From 0042fb5850086a072f5ba5de5457fa182496277d Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Wed, 20 May 2026 17:51:56 -0300
Subject: [PATCH 071/105] markdown: Add ability to wrap/unwrap codeblock
 content  (#57312)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR adds an icon button to Markdown codeblocks allowing to control
whether or not the content should be wrapped. At the moment, this is not
hard-persisted, meaning that 1) wrapping text in one codeblock instance
does not affect others, and 2) the codeblock will be reset every time
its view is recreated (i.e., closing and opening a Markdown Preview tab,
an agent thread, etc.). I intentionally kept it simple just to see how
it feels, but we can certainly consider a setting later on.

| Unwrapping | Wrapping |
|--------|--------|
| <img width="782" height="658" alt="Screenshot 2026-05-20 at 5  09
2@2x"
src="https://github.com/user-attachments/assets/e9151e91-32ba-40d4-9c65-535dec309291"
/> | <img width="736" height="604" alt="Screenshot 2026-05-20 at 5 
09@2x"
src="https://github.com/user-attachments/assets/157db6fd-ec4c-4c96-b44a-119273cbd0f9"
/> |

Release Notes:

- Added the ability to control codeblock content wrapping through the
UI.
---
 assets/icons/text_unwrap.svg                  |   6 +
 assets/icons/text_wrap.svg                    |   5 +
 crates/acp_tools/src/acp_tools.rs             |   1 +
 crates/agent_ui/src/conversation_view.rs      |   5 +
 .../src/conversation_view/thread_view.rs      |   1 +
 crates/diagnostics/src/diagnostic_renderer.rs |   1 +
 crates/editor/src/code_context_menus.rs       |   1 +
 crates/editor/src/hover_popover.rs            |   2 +
 crates/editor/src/signature_help.rs           |   4 +
 crates/icons/src/icons.rs                     |   2 +
 crates/markdown/src/html/html_rendering.rs    |   4 +
 crates/markdown/src/markdown.rs               | 124 ++++++++++++++----
 crates/markdown/src/mermaid.rs                |   4 +-
 .../src/markdown_preview_view.rs              |   1 +
 crates/workspace/src/notifications.rs         |   1 +
 crates/zed/src/zed/telemetry_log.rs           |   6 +-
 16 files changed, 142 insertions(+), 26 deletions(-)
 create mode 100644 assets/icons/text_unwrap.svg
 create mode 100644 assets/icons/text_wrap.svg

diff --git a/assets/icons/text_unwrap.svg b/assets/icons/text_unwrap.svg
new file mode 100644
index 00000000000..1dda70014be
--- /dev/null
+++ b/assets/icons/text_unwrap.svg
@@ -0,0 +1,6 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M11.748 5.74794L14 7.99998L11.748 10.252" stroke="#C6CAD0" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M14 7.99997L3 7.99997" stroke="#C6CAD0" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M8 3L8 6" stroke="#C6CAD0" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M8 10L8 13" stroke="#C6CAD0" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
diff --git a/assets/icons/text_wrap.svg b/assets/icons/text_wrap.svg
new file mode 100644
index 00000000000..64ec35a2941
--- /dev/null
+++ b/assets/icons/text_wrap.svg
@@ -0,0 +1,5 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M5.19924 8.90081L2.9472 6.64876L5.19924 4.39673" stroke="#C6CAD0" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M2.9472 6.64877H7.67649C8.00178 6.64877 8.32391 6.71285 8.6245 6.83734C8.92501 6.96184 9.19813 7.14431 9.42817 7.37434C9.6582 7.60437 9.84067 7.87746 9.96512 8.17802C10.0897 8.47856 10.1537 8.8007 10.1537 9.12601C10.1537 9.45131 10.0897 9.77345 9.96512 10.074C9.84067 10.3745 9.6582 10.6477 9.42817 10.8777C9.19813 11.1077 8.92501 11.2902 8.6245 11.4147C8.32391 11.5392 8.00178 11.6033 7.67649 11.6033H6.10005" stroke="#C6CAD0" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M13.0528 3.33331V12.6666" stroke="#C6CAD0" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
diff --git a/crates/acp_tools/src/acp_tools.rs b/crates/acp_tools/src/acp_tools.rs
index 8801379578f..695e2beb440 100644
--- a/crates/acp_tools/src/acp_tools.rs
+++ b/crates/acp_tools/src/acp_tools.rs
@@ -508,6 +508,7 @@ impl AcpTools {
                                     } else {
                                         CopyButtonVisibility::Hidden
                                     },
+                                    wrap_button_visibility: markdown::WrapButtonVisibility::Hidden,
                                     border: false,
                                 },
                             ),
diff --git a/crates/agent_ui/src/conversation_view.rs b/crates/agent_ui/src/conversation_view.rs
index 96d6476b9a3..b8e72840be6 100644
--- a/crates/agent_ui/src/conversation_view.rs
+++ b/crates/agent_ui/src/conversation_view.rs
@@ -3133,6 +3133,11 @@ fn render_agent_markdown(
         })
         .unwrap_or_default();
     MarkdownElement::new(markdown, style)
+        .code_block_renderer(markdown::CodeBlockRenderer::Default {
+            copy_button_visibility: markdown::CopyButtonVisibility::VisibleOnHover,
+            wrap_button_visibility: markdown::WrapButtonVisibility::VisibleOnHover,
+            border: false,
+        })
         .image_resolver(move |dest_url| resolve_agent_image(dest_url, &worktree_roots))
         .on_url_click(move |text, window, cx| {
             thread_view::open_link(text, &workspace, window, cx);
diff --git a/crates/agent_ui/src/conversation_view/thread_view.rs b/crates/agent_ui/src/conversation_view/thread_view.rs
index 343c21bbec8..cc182096d18 100644
--- a/crates/agent_ui/src/conversation_view/thread_view.rs
+++ b/crates/agent_ui/src/conversation_view/thread_view.rs
@@ -5991,6 +5991,7 @@ impl ThreadView {
             .render_markdown(command, style, cx)
             .code_block_renderer(CodeBlockRenderer::Default {
                 copy_button_visibility: CopyButtonVisibility::Hidden,
+                wrap_button_visibility: markdown::WrapButtonVisibility::Hidden,
                 border: false,
             });
         let copy_button = CopyButton::new("copy-command", command_text)
diff --git a/crates/diagnostics/src/diagnostic_renderer.rs b/crates/diagnostics/src/diagnostic_renderer.rs
index 21da60b5161..e1068e9c3be 100644
--- a/crates/diagnostics/src/diagnostic_renderer.rs
+++ b/crates/diagnostics/src/diagnostic_renderer.rs
@@ -240,6 +240,7 @@ impl DiagnosticBlock {
                     )
                     .code_block_renderer(markdown::CodeBlockRenderer::Default {
                         copy_button_visibility: CopyButtonVisibility::Hidden,
+                        wrap_button_visibility: markdown::WrapButtonVisibility::Hidden,
                         border: false,
                     })
                     .on_url_click({
diff --git a/crates/editor/src/code_context_menus.rs b/crates/editor/src/code_context_menus.rs
index e63f60f4e73..d54cc667c3e 100644
--- a/crates/editor/src/code_context_menus.rs
+++ b/crates/editor/src/code_context_menus.rs
@@ -1260,6 +1260,7 @@ impl CompletionsMenu {
             MarkdownElement::new(markdown, hover_markdown_style(window, cx))
                 .code_block_renderer(markdown::CodeBlockRenderer::Default {
                     copy_button_visibility: CopyButtonVisibility::Hidden,
+                    wrap_button_visibility: markdown::WrapButtonVisibility::Hidden,
                     border: false,
                 })
                 .on_url_click(open_markdown_url),
diff --git a/crates/editor/src/hover_popover.rs b/crates/editor/src/hover_popover.rs
index 6474170aace..cfee889ac27 100644
--- a/crates/editor/src/hover_popover.rs
+++ b/crates/editor/src/hover_popover.rs
@@ -1043,6 +1043,7 @@ impl InfoPopover {
                             MarkdownElement::new(markdown, hover_markdown_style(window, cx))
                                 .code_block_renderer(markdown::CodeBlockRenderer::Default {
                                     copy_button_visibility: CopyButtonVisibility::Hidden,
+                                    wrap_button_visibility: markdown::WrapButtonVisibility::Hidden,
                                     border: false,
                                 })
                                 .on_url_click(open_markdown_url)
@@ -1157,6 +1158,7 @@ impl DiagnosticPopover {
                                 )
                                 .code_block_renderer(markdown::CodeBlockRenderer::Default {
                                     copy_button_visibility: CopyButtonVisibility::Hidden,
+                                    wrap_button_visibility: markdown::WrapButtonVisibility::Hidden,
                                     border: false,
                                 })
                                 .on_url_click(
diff --git a/crates/editor/src/signature_help.rs b/crates/editor/src/signature_help.rs
index 6305fc73e44..6ec2fe6152c 100644
--- a/crates/editor/src/signature_help.rs
+++ b/crates/editor/src/signature_help.rs
@@ -409,6 +409,8 @@ impl SignatureHelpPopover {
                                     )
                                     .code_block_renderer(markdown::CodeBlockRenderer::Default {
                                         copy_button_visibility: CopyButtonVisibility::Hidden,
+                                        wrap_button_visibility:
+                                            markdown::WrapButtonVisibility::Hidden,
                                         border: false,
                                     })
                                     .on_url_click(open_markdown_url),
@@ -421,6 +423,8 @@ impl SignatureHelpPopover {
                                 MarkdownElement::new(description, hover_markdown_style(window, cx))
                                     .code_block_renderer(markdown::CodeBlockRenderer::Default {
                                         copy_button_visibility: CopyButtonVisibility::Hidden,
+                                        wrap_button_visibility:
+                                            markdown::WrapButtonVisibility::Hidden,
                                         border: false,
                                     })
                                     .on_url_click(open_markdown_url),
diff --git a/crates/icons/src/icons.rs b/crates/icons/src/icons.rs
index 83a7a1e9c4e..1559622fc98 100644
--- a/crates/icons/src/icons.rs
+++ b/crates/icons/src/icons.rs
@@ -239,6 +239,8 @@ pub enum IconName {
     Terminal,
     TerminalAlt,
     TextSnippet,
+    TextWrap,
+    TextUnwrap,
     ThinkingMode,
     ThinkingModeOff,
     Thread,
diff --git a/crates/markdown/src/html/html_rendering.rs b/crates/markdown/src/html/html_rendering.rs
index 6387164922c..25e869625fb 100644
--- a/crates/markdown/src/html/html_rendering.rs
+++ b/crates/markdown/src/html/html_rendering.rs
@@ -561,6 +561,8 @@ mod tests {
         });
     }
 
+    use crate::WrapButtonVisibility;
+
     fn render_markdown_text(markdown: &str, cx: &mut TestAppContext) -> crate::RenderedText {
         struct TestWindow;
 
@@ -582,6 +584,7 @@ mod tests {
                 MarkdownElement::new(markdown, MarkdownStyle::default()).code_block_renderer(
                     CodeBlockRenderer::Default {
                         copy_button_visibility: CopyButtonVisibility::Hidden,
+                        wrap_button_visibility: WrapButtonVisibility::Hidden,
                         border: false,
                     },
                 )
@@ -642,6 +645,7 @@ mod tests {
                 MarkdownElement::new(markdown, MarkdownStyle::default()).code_block_renderer(
                     CodeBlockRenderer::Default {
                         copy_button_visibility: CopyButtonVisibility::Hidden,
+                        wrap_button_visibility: WrapButtonVisibility::Hidden,
                         border: false,
                     },
                 )
diff --git a/crates/markdown/src/markdown.rs b/crates/markdown/src/markdown.rs
index 44e87f55677..1f763d390b9 100644
--- a/crates/markdown/src/markdown.rs
+++ b/crates/markdown/src/markdown.rs
@@ -334,6 +334,7 @@ pub struct Markdown {
     mermaid_state: MermaidState,
     mermaid_showing_code: HashSet<usize>,
     copied_code_blocks: HashSet<ElementId>,
+    wrapped_code_blocks: HashSet<usize>,
     code_block_scroll_handles: BTreeMap<usize, ScrollHandle>,
     context_menu_link: Option<SharedString>,
     context_menu_selected_text: Option<String>,
@@ -356,9 +357,17 @@ pub enum CopyButtonVisibility {
     VisibleOnHover,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum WrapButtonVisibility {
+    Hidden,
+    AlwaysVisible,
+    VisibleOnHover,
+}
+
 pub enum CodeBlockRenderer {
     Default {
         copy_button_visibility: CopyButtonVisibility,
+        wrap_button_visibility: WrapButtonVisibility,
         border: bool,
     },
     Custom {
@@ -505,6 +514,7 @@ impl Markdown {
             mermaid_state: MermaidState::default(),
             mermaid_showing_code: HashSet::default(),
             copied_code_blocks: HashSet::default(),
+            wrapped_code_blocks: HashSet::default(),
             code_block_scroll_handles: BTreeMap::default(),
             context_menu_link: None,
             context_menu_selected_text: None,
@@ -528,6 +538,16 @@ impl Markdown {
         )
     }
 
+    fn is_code_block_wrapped(&self, id: usize) -> bool {
+        self.wrapped_code_blocks.contains(&id)
+    }
+
+    fn toggle_code_block_wrap(&mut self, id: usize) {
+        if !self.wrapped_code_blocks.remove(&id) {
+            self.wrapped_code_blocks.insert(id);
+        }
+    }
+
     fn code_block_scroll_handle(&mut self, id: usize) -> ScrollHandle {
         self.code_block_scroll_handles
             .entry(id)
@@ -1073,6 +1093,7 @@ impl MarkdownElement {
             style,
             code_block_renderer: CodeBlockRenderer::Default {
                 copy_button_visibility: CopyButtonVisibility::VisibleOnHover,
+                wrap_button_visibility: WrapButtonVisibility::Hidden,
                 border: false,
             },
             on_url_click: None,
@@ -1891,11 +1912,18 @@ impl Element for MarkdownElement {
                                     parent_container.style().refine(&self.style.code_block);
                                     builder.push_div(parent_container, range, markdown_end);
 
+                                    let is_wrapped =
+                                        self.markdown.read(cx).is_code_block_wrapped(range.start);
+
                                     let code_block = div()
                                         .id(("code-block", range.start))
                                         .rounded_lg()
                                         .map(|mut code_block| {
-                                            if let Some(scroll_handle) = scroll_handle.as_ref() {
+                                            if is_wrapped {
+                                                code_block.w_full()
+                                            } else if let Some(scroll_handle) =
+                                                scroll_handle.as_ref()
+                                            {
                                                 code_block.style().restrict_scroll_to_axis =
                                                     Some(true);
                                                 code_block
@@ -2134,10 +2162,14 @@ impl Element for MarkdownElement {
 
                         if let CodeBlockRenderer::Default {
                             copy_button_visibility,
+                            wrap_button_visibility,
                             ..
                         } = &self.code_block_renderer
-                            && *copy_button_visibility != CopyButtonVisibility::Hidden
+                            && (*copy_button_visibility != CopyButtonVisibility::Hidden
+                                || *wrap_button_visibility != WrapButtonVisibility::Hidden)
                         {
+                            let copy_button_visibility = *copy_button_visibility;
+                            let wrap_button_visibility = *wrap_button_visibility;
                             builder.modify_current_div(|el| {
                                 let content_range = parser::extract_code_block_content_range(
                                     &parsed_markdown.source()[range.clone()],
@@ -2146,28 +2178,48 @@ impl Element for MarkdownElement {
                                     ..content_range.end + range.start;
 
                                 let code = parsed_markdown.source()[content_range].to_string();
-                                let codeblock = render_copy_code_block_button(
-                                    range.end,
-                                    code,
-                                    self.markdown.clone(),
-                                );
-                                el.child(
-                                    h_flex()
-                                        .w_4()
-                                        .absolute()
-                                        .justify_end()
-                                        .when_else(
-                                            *copy_button_visibility
-                                                == CopyButtonVisibility::VisibleOnHover,
-                                            |this| {
-                                                this.top_0()
-                                                    .right_0()
-                                                    .visible_on_hover("code_block")
-                                            },
-                                            |this| this.top_1p5().right_1p5(),
-                                        )
-                                        .child(codeblock),
-                                )
+
+                                let any_hover = copy_button_visibility
+                                    == CopyButtonVisibility::VisibleOnHover
+                                    || wrap_button_visibility
+                                        == WrapButtonVisibility::VisibleOnHover;
+                                let any_always = copy_button_visibility
+                                    == CopyButtonVisibility::AlwaysVisible
+                                    || wrap_button_visibility
+                                        == WrapButtonVisibility::AlwaysVisible;
+                                let use_hover = any_hover && !any_always;
+
+                                let mut button_row = h_flex()
+                                    .gap_0p5()
+                                    .absolute()
+                                    .bg(cx.theme().colors().editor_background)
+                                    .when_else(
+                                        use_hover,
+                                        |this| {
+                                            this.top_1().right_1().visible_on_hover("code_block")
+                                        },
+                                        |this| this.top_1p5().right_1p5(),
+                                    );
+
+                                if wrap_button_visibility != WrapButtonVisibility::Hidden {
+                                    let is_wrapped =
+                                        self.markdown.read(cx).is_code_block_wrapped(range.start);
+                                    button_row = button_row.child(render_wrap_code_block_button(
+                                        range.start,
+                                        is_wrapped,
+                                        self.markdown.clone(),
+                                    ));
+                                }
+
+                                if copy_button_visibility != CopyButtonVisibility::Hidden {
+                                    button_row = button_row.child(render_copy_code_block_button(
+                                        range.end,
+                                        code,
+                                        self.markdown.clone(),
+                                    ));
+                                }
+
+                                el.child(button_row)
                             });
                         }
 
@@ -2418,6 +2470,29 @@ fn apply_heading_style(
     heading
 }
 
+fn render_wrap_code_block_button(
+    id: usize,
+    is_wrapped: bool,
+    markdown: Entity<Markdown>,
+) -> impl IntoElement {
+    let (icon, tooltip) = if is_wrapped {
+        (IconName::TextUnwrap, "Unwrap Content")
+    } else {
+        (IconName::TextWrap, "Wrap Content")
+    };
+
+    IconButton::new(("wrap-code-block", id), icon)
+        .icon_size(IconSize::Small)
+        .icon_color(Color::Muted)
+        .tooltip(Tooltip::text(tooltip))
+        .on_click(move |_event, _window, cx| {
+            markdown.update(cx, |markdown, cx| {
+                markdown.toggle_code_block_wrap(id);
+                cx.notify();
+            });
+        })
+}
+
 fn render_copy_code_block_button(
     id: usize,
     code: String,
@@ -3434,6 +3509,7 @@ mod tests {
                 MarkdownElement::new(markdown, MarkdownStyle::default()).code_block_renderer(
                     CodeBlockRenderer::Default {
                         copy_button_visibility: CopyButtonVisibility::Hidden,
+                        wrap_button_visibility: WrapButtonVisibility::Hidden,
                         border: false,
                     },
                 )
diff --git a/crates/markdown/src/mermaid.rs b/crates/markdown/src/mermaid.rs
index 250edeea3a5..019cb6d78ad 100644
--- a/crates/markdown/src/mermaid.rs
+++ b/crates/markdown/src/mermaid.rs
@@ -585,7 +585,7 @@ mod tests {
     };
     use crate::{
         CodeBlockRenderer, CopyButtonVisibility, Markdown, MarkdownElement, MarkdownOptions,
-        MarkdownStyle,
+        MarkdownStyle, WrapButtonVisibility,
     };
     use collections::HashMap;
     use gpui::{Context, Hsla, IntoElement, Render, RenderImage, TestAppContext, Window, size};
@@ -644,6 +644,7 @@ mod tests {
                 MarkdownElement::new(markdown, MarkdownStyle::default()).code_block_renderer(
                     CodeBlockRenderer::Default {
                         copy_button_visibility: CopyButtonVisibility::Hidden,
+                        wrap_button_visibility: WrapButtonVisibility::Hidden,
                         border: false,
                     },
                 )
@@ -924,6 +925,7 @@ mod tests {
                 MarkdownElement::new(markdown.clone(), MarkdownStyle::default())
                     .code_block_renderer(CodeBlockRenderer::Default {
                         copy_button_visibility: CopyButtonVisibility::Hidden,
+                        wrap_button_visibility: WrapButtonVisibility::Hidden,
                         border: false,
                     })
             },
diff --git a/crates/markdown_preview/src/markdown_preview_view.rs b/crates/markdown_preview/src/markdown_preview_view.rs
index 4413e6b0f12..38ce126badb 100644
--- a/crates/markdown_preview/src/markdown_preview_view.rs
+++ b/crates/markdown_preview/src/markdown_preview_view.rs
@@ -623,6 +623,7 @@ impl MarkdownPreviewView {
         let mut markdown_element = MarkdownElement::new(self.markdown.clone(), markdown_style)
             .code_block_renderer(CodeBlockRenderer::Default {
                 copy_button_visibility: CopyButtonVisibility::VisibleOnHover,
+                wrap_button_visibility: markdown::WrapButtonVisibility::Hidden,
                 border: false,
             })
             .scroll_handle(self.scroll_handle.clone())
diff --git a/crates/workspace/src/notifications.rs b/crates/workspace/src/notifications.rs
index ce54765e3ff..689160b435f 100644
--- a/crates/workspace/src/notifications.rs
+++ b/crates/workspace/src/notifications.rs
@@ -402,6 +402,7 @@ impl Render for LanguageServerPrompt {
                             .text_size(TextSize::Small.rems(cx))
                             .code_block_renderer(markdown::CodeBlockRenderer::Default {
                                 copy_button_visibility: CopyButtonVisibility::Hidden,
+                                wrap_button_visibility: markdown::WrapButtonVisibility::Hidden,
                                 border: false,
                             })
                             .on_url_click(|link, _, cx| cx.open_url(&link)),
diff --git a/crates/zed/src/zed/telemetry_log.rs b/crates/zed/src/zed/telemetry_log.rs
index 7df7e83d258..062fd5f0f28 100644
--- a/crates/zed/src/zed/telemetry_log.rs
+++ b/crates/zed/src/zed/telemetry_log.rs
@@ -12,7 +12,10 @@ use gpui::{
     StyleRefinement, Task, TextStyleRefinement, Window, list, prelude::*,
 };
 use language::LanguageRegistry;
-use markdown::{CodeBlockRenderer, CopyButtonVisibility, Markdown, MarkdownElement, MarkdownStyle};
+use markdown::{
+    CodeBlockRenderer, CopyButtonVisibility, Markdown, MarkdownElement, MarkdownStyle,
+    WrapButtonVisibility,
+};
 use project::Project;
 use settings::Settings;
 use telemetry_events::{Event, EventWrapper};
@@ -429,6 +432,7 @@ impl TelemetryLogView {
                             } else {
                                 CopyButtonVisibility::Hidden
                             },
+                            wrap_button_visibility: WrapButtonVisibility::Hidden,
                             border: false,
                         }),
                     ),

From 251456cf20887b91e0ba2d507b47ace14d4c24ff Mon Sep 17 00:00:00 2001
From: Cole Miller <cole@zed.dev>
Date: Wed, 20 May 2026 17:41:33 -0400
Subject: [PATCH 072/105] Add some debug logging to understand hangs in the git
 store's `compute_snapshot` (#57317)

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [ ] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Release Notes:

- N/A
---
 crates/project/src/git_store.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/crates/project/src/git_store.rs b/crates/project/src/git_store.rs
index ee6063c0e4e..ad5174ec365 100644
--- a/crates/project/src/git_store.rs
+++ b/crates/project/src/git_store.rs
@@ -9144,6 +9144,8 @@ async fn compute_snapshot(
     backend: Arc<dyn GitRepository>,
     cx: &mut AsyncApp,
 ) -> Result<RepositorySnapshot> {
+    log::debug!("starting compute snapshot");
+
     let (id, work_directory_abs_path, prev_snapshot) = this.update(cx, |this, _| {
         this.paths_needing_status_update.clear();
         (
@@ -9175,6 +9177,7 @@ async fn compute_snapshot(
             }
         })
         .await?;
+    log::debug!("fetched branches, head commit, worktrees");
     let branch = branches.iter().find(|branch| branch.is_head).cloned();
     let branch_list: Arc<[Branch]> = branches.into();
 
@@ -9198,6 +9201,8 @@ async fn compute_snapshot(
         })
         .await?;
 
+    log::debug!("fetched remotes");
+
     let snapshot = this.update(cx, |this, cx| {
         let head_changed =
             branch != this.snapshot.branch || head_commit != this.snapshot.head_commit;
@@ -9257,6 +9262,7 @@ async fn compute_snapshot(
             }
         })
         .await?;
+    log::debug!("fetched statuses, diff stats, stash entries");
 
     let diff_stat_map: HashMap<&RepoPath, DiffStat> =
         diff_stats.entries.iter().map(|(p, s)| (p, *s)).collect();

From b3ce9a49f7e564a581d2a343b2c85fc96130aa92 Mon Sep 17 00:00:00 2001
From: Ben Kunkle <ben@zed.dev>
Date: Wed, 20 May 2026 18:42:31 -0400
Subject: [PATCH 073/105] ep: Don't open unnecessary files during context
 collection (#57318)

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [ ] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Closes #ISSUE

Release Notes:

- N/A or Added/Fixed/Improved ...
---
 .../src/edit_prediction_context.rs            | 120 +++++++++---------
 crates/project/src/lsp_command.rs             |  42 +++++-
 crates/project/src/lsp_store.rs               |  70 +++++++++-
 .../project/src/lsp_store/lsp_ext_command.rs  |   1 +
 crates/project/src/project.rs                 |  36 ++++++
 crates/proto/proto/lsp.proto                  |   2 +
 6 files changed, 202 insertions(+), 69 deletions(-)

diff --git a/crates/edit_prediction_context/src/edit_prediction_context.rs b/crates/edit_prediction_context/src/edit_prediction_context.rs
index a5dd0c15783..5671df6092e 100644
--- a/crates/edit_prediction_context/src/edit_prediction_context.rs
+++ b/crates/edit_prediction_context/src/edit_prediction_context.rs
@@ -286,7 +286,11 @@ impl RelatedExcerptStore {
                             let buffer = buffer.upgrade()?;
                             let definitions = project
                                 .update(cx, |project, cx| {
-                                    project.definitions(&buffer, identifier.range.start, cx)
+                                    project.workspace_definitions(
+                                        &buffer,
+                                        identifier.range.start,
+                                        cx,
+                                    )
                                 })
                                 .ok()?;
                             let type_definitions = project
@@ -296,7 +300,11 @@ impl RelatedExcerptStore {
                                     if is_tombi_lsp_in_toml(project, &buffer, cx) {
                                         return Task::ready(Ok(None));
                                     }
-                                    project.type_definitions(&buffer, identifier.range.start, cx)
+                                    project.workspace_type_definitions(
+                                        &buffer,
+                                        identifier.range.start,
+                                        cx,
+                                    )
                                 })
                                 .ok()?;
                             Some((definitions, type_definitions))
@@ -304,7 +312,6 @@ impl RelatedExcerptStore {
                     };
 
                     let cx = async_cx.clone();
-                    let project = project.clone();
                     async move {
                         match task {
                             DefinitionTask::CacheHit(cache_entry) => {
@@ -323,39 +330,39 @@ impl RelatedExcerptStore {
                                     .flatten()
                                     .unwrap_or_default();
 
-                                Some(cx.update(|cx| {
-                                    let definitions: SmallVec<[CachedDefinition; 1]> =
-                                        definition_locations
-                                            .into_iter()
-                                            .filter_map(|location| {
-                                                process_definition(location, &project, cx)
-                                            })
-                                            .collect();
+                                let definitions: SmallVec<[CachedDefinition; 1]> =
+                                    definition_locations
+                                        .into_iter()
+                                        .filter_map(|location| {
+                                            let mut cx = cx.clone();
+                                            process_definition(location, &mut cx)
+                                        })
+                                        .collect();
 
-                                    let type_definitions: SmallVec<[CachedDefinition; 1]> =
-                                        type_definition_locations
-                                            .into_iter()
-                                            .filter_map(|location| {
-                                                process_definition(location, &project, cx)
+                                let type_definitions: SmallVec<[CachedDefinition; 1]> =
+                                    type_definition_locations
+                                        .into_iter()
+                                        .filter_map(|location| {
+                                            let mut cx = cx.clone();
+                                            process_definition(location, &mut cx)
+                                        })
+                                        .filter(|type_def| {
+                                            !definitions.iter().any(|def| {
+                                                def.buffer.entity_id()
+                                                    == type_def.buffer.entity_id()
+                                                    && def.anchor_range == type_def.anchor_range
                                             })
-                                            .filter(|type_def| {
-                                                !definitions.iter().any(|def| {
-                                                    def.buffer.entity_id()
-                                                        == type_def.buffer.entity_id()
-                                                        && def.anchor_range == type_def.anchor_range
-                                                })
-                                            })
-                                            .collect();
+                                        })
+                                        .collect();
 
-                                    (
-                                        identifier,
-                                        Arc::new(CacheEntry {
-                                            definitions,
-                                            type_definitions,
-                                        }),
-                                        Some(duration),
-                                    )
-                                }))
+                                Some((
+                                    identifier,
+                                    Arc::new(CacheEntry {
+                                        definitions,
+                                        type_definitions,
+                                    }),
+                                    Some(duration),
+                                ))
                             }
                         }
                     }
@@ -581,34 +588,29 @@ use language::ToPoint as _;
 
 const MAX_TARGET_LEN: usize = 128;
 
-fn process_definition(
-    location: LocationLink,
-    project: &Entity<Project>,
-    cx: &mut App,
-) -> Option<CachedDefinition> {
-    let buffer = location.target.buffer.read(cx);
-    let anchor_range = location.target.range;
-    let file = buffer.file()?;
-    let worktree = project.read(cx).worktree_for_id(file.worktree_id(cx), cx)?;
-    if worktree.read(cx).is_single_file() {
-        return None;
-    }
-
-    // If the target range is large, it likely means we requested the definition of an entire module.
-    // For individual definitions, the target range should be small as it only covers the symbol.
-    let buffer = location.target.buffer.read(cx);
-    let target_len = anchor_range.to_offset(&buffer).len();
-    if target_len > MAX_TARGET_LEN {
-        return None;
-    }
-
-    Some(CachedDefinition {
-        path: ProjectPath {
+fn process_definition(location: LocationLink, cx: &mut AsyncApp) -> Option<CachedDefinition> {
+    cx.update(|cx| {
+        let buffer = location.target.buffer;
+        let buffer_snapshot = buffer.read(cx);
+        let file = buffer_snapshot.file()?;
+        let path = ProjectPath {
             worktree_id: file.worktree_id(cx),
             path: file.path().clone(),
-        },
-        buffer: location.target.buffer,
-        anchor_range,
+        };
+        let anchor_range = location.target.range;
+
+        // If the target range is large, it likely means we requested the definition of an entire module.
+        // For individual definitions, the target range should be small as it only covers the symbol.
+        let target_len = anchor_range.to_offset(&buffer_snapshot).len();
+        if target_len > MAX_TARGET_LEN {
+            return None;
+        }
+
+        Some(CachedDefinition {
+            path,
+            buffer: buffer.clone(),
+            anchor_range,
+        })
     })
 }
 
diff --git a/crates/project/src/lsp_command.rs b/crates/project/src/lsp_command.rs
index e110176dd20..438f8f66375 100644
--- a/crates/project/src/lsp_command.rs
+++ b/crates/project/src/lsp_command.rs
@@ -189,6 +189,7 @@ pub(crate) struct PerformRename {
 #[derive(Debug, Clone, Copy)]
 pub struct GetDefinitions {
     pub position: PointUtf16,
+    pub workspace_only: bool,
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -199,6 +200,7 @@ pub(crate) struct GetDeclarations {
 #[derive(Debug, Clone, Copy)]
 pub(crate) struct GetTypeDefinitions {
     pub position: PointUtf16,
+    pub workspace_only: bool,
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -689,7 +691,15 @@ impl LspCommand for GetDefinitions {
         server_id: LanguageServerId,
         cx: AsyncApp,
     ) -> Result<Vec<LocationLink>> {
-        location_links_from_lsp(message, lsp_store, buffer, server_id, cx).await
+        location_links_from_lsp(
+            message,
+            lsp_store,
+            buffer,
+            server_id,
+            self.workspace_only,
+            cx,
+        )
+        .await
     }
 
     fn to_proto(&self, project_id: u64, buffer: &Buffer) -> proto::GetDefinition {
@@ -700,6 +710,7 @@ impl LspCommand for GetDefinitions {
                 &buffer.anchor_before(self.position),
             )),
             version: serialize_version(&buffer.version()),
+            workspace_only: self.workspace_only,
         }
     }
 
@@ -720,6 +731,7 @@ impl LspCommand for GetDefinitions {
             .await?;
         Ok(Self {
             position: buffer.read_with(&cx, |buffer, _| position.to_point_utf16(buffer)),
+            workspace_only: message.workspace_only,
         })
     }
 
@@ -792,7 +804,7 @@ impl LspCommand for GetDeclarations {
         server_id: LanguageServerId,
         cx: AsyncApp,
     ) -> Result<Vec<LocationLink>> {
-        location_links_from_lsp(message, lsp_store, buffer, server_id, cx).await
+        location_links_from_lsp(message, lsp_store, buffer, server_id, false, cx).await
     }
 
     fn to_proto(&self, project_id: u64, buffer: &Buffer) -> proto::GetDeclaration {
@@ -894,7 +906,7 @@ impl LspCommand for GetImplementations {
         server_id: LanguageServerId,
         cx: AsyncApp,
     ) -> Result<Vec<LocationLink>> {
-        location_links_from_lsp(message, lsp_store, buffer, server_id, cx).await
+        location_links_from_lsp(message, lsp_store, buffer, server_id, false, cx).await
     }
 
     fn to_proto(&self, project_id: u64, buffer: &Buffer) -> proto::GetImplementation {
@@ -993,7 +1005,7 @@ impl LspCommand for GetTypeDefinitions {
         server_id: LanguageServerId,
         cx: AsyncApp,
     ) -> Result<Vec<LocationLink>> {
-        location_links_from_lsp(message, project, buffer, server_id, cx).await
+        location_links_from_lsp(message, project, buffer, server_id, self.workspace_only, cx).await
     }
 
     fn to_proto(&self, project_id: u64, buffer: &Buffer) -> proto::GetTypeDefinition {
@@ -1004,6 +1016,7 @@ impl LspCommand for GetTypeDefinitions {
                 &buffer.anchor_before(self.position),
             )),
             version: serialize_version(&buffer.version()),
+            workspace_only: self.workspace_only,
         }
     }
 
@@ -1024,6 +1037,7 @@ impl LspCommand for GetTypeDefinitions {
             .await?;
         Ok(Self {
             position: buffer.read_with(&cx, |buffer, _| position.to_point_utf16(buffer)),
+            workspace_only: message.workspace_only,
         })
     }
 
@@ -1148,6 +1162,7 @@ pub async fn location_links_from_lsp(
     lsp_store: Entity<LspStore>,
     buffer: Entity<Buffer>,
     server_id: LanguageServerId,
+    workspace_only: bool,
     mut cx: AsyncApp,
 ) -> Result<Vec<LocationLink>> {
     let message = match message {
@@ -1179,6 +1194,25 @@ pub async fn location_links_from_lsp(
     let (_, language_server) = language_server_for_buffer(&lsp_store, &buffer, server_id, &mut cx)?;
     let mut definitions = Vec::new();
     for (origin_range, target_uri, target_range) in unresolved_links {
+        if workspace_only
+            && !lsp_store.update(&mut cx, |this, cx| {
+                use util::paths::UrlExt as _;
+                let worktree_store = this.worktree_store().read(cx);
+                let path_style = worktree_store.path_style();
+                let Ok(abs_path) = target_uri.clone().to_file_path_ext(path_style) else {
+                    return false;
+                };
+                worktree_store
+                    .find_worktree(&abs_path, cx)
+                    .is_some_and(|(worktree, _)| {
+                        let worktree = worktree.read(cx);
+                        worktree.is_visible() && !worktree.is_single_file()
+                    })
+            })
+        {
+            continue;
+        }
+
         let target_buffer_handle = lsp_store
             .update(&mut cx, |this, cx| {
                 this.open_local_buffer_via_lsp(target_uri, language_server.server_id(), cx)
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index fd738b0f7ad..d288f0021fc 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -5938,9 +5938,31 @@ impl LspStore {
         buffer: &Entity<Buffer>,
         position: PointUtf16,
         cx: &mut Context<Self>,
+    ) -> Task<Result<Option<Vec<LocationLink>>>> {
+        self.definitions_with_filter(buffer, position, false, cx)
+    }
+
+    pub fn workspace_definitions(
+        &mut self,
+        buffer: &Entity<Buffer>,
+        position: PointUtf16,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<Option<Vec<LocationLink>>>> {
+        self.definitions_with_filter(buffer, position, true, cx)
+    }
+
+    fn definitions_with_filter(
+        &mut self,
+        buffer: &Entity<Buffer>,
+        position: PointUtf16,
+        workspace_only: bool,
+        cx: &mut Context<Self>,
     ) -> Task<Result<Option<Vec<LocationLink>>>> {
         if let Some((upstream_client, project_id)) = self.upstream_client() {
-            let request = GetDefinitions { position };
+            let request = GetDefinitions {
+                position,
+                workspace_only,
+            };
             if !self.is_capable_for_proto_request(buffer, &request, cx) {
                 return Task::ready(Ok(None));
             }
@@ -5965,7 +5987,11 @@ impl LspStore {
                     return Ok(None);
                 };
                 let actions = join_all(responses.payload.into_iter().map(|response| {
-                    GetDefinitions { position }.response_from_proto(
+                    GetDefinitions {
+                        position,
+                        workspace_only,
+                    }
+                    .response_from_proto(
                         response.response,
                         lsp_store.clone(),
                         buffer.clone(),
@@ -5988,7 +6014,10 @@ impl LspStore {
             let definitions_task = self.request_multiple_lsp_locally(
                 buffer,
                 Some(position),
-                GetDefinitions { position },
+                GetDefinitions {
+                    position,
+                    workspace_only,
+                },
                 cx,
             );
             cx.background_spawn(async move {
@@ -6078,9 +6107,31 @@ impl LspStore {
         buffer: &Entity<Buffer>,
         position: PointUtf16,
         cx: &mut Context<Self>,
+    ) -> Task<Result<Option<Vec<LocationLink>>>> {
+        self.type_definitions_with_filter(buffer, position, false, cx)
+    }
+
+    pub fn workspace_type_definitions(
+        &mut self,
+        buffer: &Entity<Buffer>,
+        position: PointUtf16,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<Option<Vec<LocationLink>>>> {
+        self.type_definitions_with_filter(buffer, position, true, cx)
+    }
+
+    fn type_definitions_with_filter(
+        &mut self,
+        buffer: &Entity<Buffer>,
+        position: PointUtf16,
+        workspace_only: bool,
+        cx: &mut Context<Self>,
     ) -> Task<Result<Option<Vec<LocationLink>>>> {
         if let Some((upstream_client, project_id)) = self.upstream_client() {
-            let request = GetTypeDefinitions { position };
+            let request = GetTypeDefinitions {
+                position,
+                workspace_only,
+            };
             if !self.is_capable_for_proto_request(buffer, &request, cx) {
                 return Task::ready(Ok(None));
             }
@@ -6103,7 +6154,11 @@ impl LspStore {
                     return Ok(None);
                 };
                 let actions = join_all(responses.payload.into_iter().map(|response| {
-                    GetTypeDefinitions { position }.response_from_proto(
+                    GetTypeDefinitions {
+                        position,
+                        workspace_only,
+                    }
+                    .response_from_proto(
                         response.response,
                         lsp_store.clone(),
                         buffer.clone(),
@@ -6126,7 +6181,10 @@ impl LspStore {
             let type_definitions_task = self.request_multiple_lsp_locally(
                 buffer,
                 Some(position),
-                GetTypeDefinitions { position },
+                GetTypeDefinitions {
+                    position,
+                    workspace_only,
+                },
                 cx,
             );
             cx.background_spawn(async move {
diff --git a/crates/project/src/lsp_store/lsp_ext_command.rs b/crates/project/src/lsp_store/lsp_ext_command.rs
index bb994492d00..dd7010275dc 100644
--- a/crates/project/src/lsp_store/lsp_ext_command.rs
+++ b/crates/project/src/lsp_store/lsp_ext_command.rs
@@ -443,6 +443,7 @@ impl LspCommand for GoToParentModule {
             lsp_store,
             buffer,
             server_id,
+            false,
             cx,
         )
         .await
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 1674a26b871..12726349a8b 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -4180,6 +4180,24 @@ impl Project {
         })
     }
 
+    pub fn workspace_definitions<T: ToPointUtf16>(
+        &mut self,
+        buffer: &Entity<Buffer>,
+        position: T,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<Option<Vec<LocationLink>>>> {
+        let position = position.to_point_utf16(buffer.read(cx));
+        let guard = self.retain_remotely_created_models(cx);
+        let task = self.lsp_store.update(cx, |lsp_store, cx| {
+            lsp_store.workspace_definitions(buffer, position, cx)
+        });
+        cx.background_spawn(async move {
+            let result = task.await;
+            drop(guard);
+            result
+        })
+    }
+
     pub fn declarations<T: ToPointUtf16>(
         &mut self,
         buffer: &Entity<Buffer>,
@@ -4216,6 +4234,24 @@ impl Project {
         })
     }
 
+    pub fn workspace_type_definitions<T: ToPointUtf16>(
+        &mut self,
+        buffer: &Entity<Buffer>,
+        position: T,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<Option<Vec<LocationLink>>>> {
+        let position = position.to_point_utf16(buffer.read(cx));
+        let guard = self.retain_remotely_created_models(cx);
+        let task = self.lsp_store.update(cx, |lsp_store, cx| {
+            lsp_store.workspace_type_definitions(buffer, position, cx)
+        });
+        cx.background_spawn(async move {
+            let result = task.await;
+            drop(guard);
+            result
+        })
+    }
+
     pub fn implementations<T: ToPointUtf16>(
         &mut self,
         buffer: &Entity<Buffer>,
diff --git a/crates/proto/proto/lsp.proto b/crates/proto/proto/lsp.proto
index 813f9e9ec65..f6891a9170e 100644
--- a/crates/proto/proto/lsp.proto
+++ b/crates/proto/proto/lsp.proto
@@ -8,6 +8,7 @@ message GetDefinition {
   uint64 buffer_id = 2;
   Anchor position = 3;
   repeated VectorClockEntry version = 4;
+  bool workspace_only = 5;
 }
 
 message GetDefinitionResponse {
@@ -30,6 +31,7 @@ message GetTypeDefinition {
   uint64 buffer_id = 2;
   Anchor position = 3;
   repeated VectorClockEntry version = 4;
+  bool workspace_only = 5;
 }
 
 message GetTypeDefinitionResponse {

From ee5c7b6d45faeccd40a285be63a853753c91eff0 Mon Sep 17 00:00:00 2001
From: Tom Aylott <thomas.42@gmail.com>
Date: Wed, 20 May 2026 22:51:14 +0000
Subject: [PATCH 074/105] Improve link pattern parsing to trim punctuation
 wrappers (#45457)

Closes # (none)

## Summary

Improved the jump-to-definition reliability for file paths in prose
strings (comments, markdown, etc.) by smarter stripping of surrounding
punctuation.

This allows `cmd/ctrl-click` to work on file paths in contexts like:
- **Markdown backticks**: `` `path/to/file` ``
- **Markdown links**: `[link](path/to/file)`
- **Parentheses**: `(see path/to/file)`
- **Sentence endings**: `Check path/to/file.`
- **Code spans**: `` `cat path/to/file` ``

## Technical Details

- Updated `link_pattern_file_candidates` in `hover_links.rs` to
iteratively trim common leading and trailing punctuation characters.
- Candidate generation now produces multiple variations (trimmed, regex
match, raw) ordered by specificity (most trimmed first).
- Refactored `test_hover_filenames` to be DRY: it now uses a single base
document string and targeted replacements, making it easier to add new
prose test cases without duplication.

Release Notes:

- Improved jump-to-definition reliability for file paths wrapped in
punctuation (backticks, parens, sentence endings).

---------

Co-authored-by: Martin Ye <martin@zed.dev>
Co-authored-by: MartinYe1234 <52641447+MartinYe1234@users.noreply.github.com>
---
 crates/editor/src/hover_links.rs | 478 +++++++++++++++----------------
 1 file changed, 231 insertions(+), 247 deletions(-)

diff --git a/crates/editor/src/hover_links.rs b/crates/editor/src/hover_links.rs
index 3c9e13d00df..7dbf0bab0e8 100644
--- a/crates/editor/src/hover_links.rs
+++ b/crates/editor/src/hover_links.rs
@@ -767,23 +767,66 @@ pub(crate) async fn find_file(
     None
 }
 
-// Tries to capture potentially inlined links, like those found in markdown,
-// e.g. [LinkTitle](link_file.txt)
-// Since files can have parens, we should always return the full string
-// (literally, [LinkTitle](link_file.txt)) as a candidate.
+// Generates candidate file paths by stripping common punctuation wrappers.
+// Handles markdown patterns like [title](path), `path`, (path), as well as
+// partial wrappers where punctuation only appears on one side (e.g. path) or path`).
+// Returns candidates ordered from most-specific (most trimmed) to least-specific (raw).
 fn link_pattern_file_candidates(candidate: &str) -> Vec<(String, Range<usize>)> {
     static MD_LINK_REGEX: LazyLock<Regex> =
         LazyLock::new(|| Regex::new(r"]\(([^)]*)\)").expect("Failed to create REGEX"));
 
+    // Punctuation that commonly wraps file paths in prose/markdown
+    const LEADING_PUNCTUATION: &[char] = &['`', '(', '[', '{', '<', '"', '\''];
+    const TRAILING_PUNCTUATION: &[char] = &[
+        '`', ')', ']', '}', '>', '"', '\'', '.', ',', ':', ';', '!', '?',
+    ];
+
     let candidate_len = candidate.len();
+    let mut candidates = Vec::new();
 
-    let mut candidates = vec![(candidate.to_string(), 0..candidate_len)];
+    // Trim leading and trailing punctuation iteratively
+    let mut start = 0;
+    let mut end = candidate_len;
 
-    if let Some(captures) = MD_LINK_REGEX.captures(candidate) {
-        if let Some(link) = captures.get(1) {
-            candidates.push((link.as_str().to_string(), link.range()));
+    // Trim leading punctuation
+    for ch in candidate.chars() {
+        if LEADING_PUNCTUATION.contains(&ch) {
+            start += ch.len_utf8();
+        } else {
+            break;
         }
     }
+
+    // Trim trailing punctuation
+    for ch in candidate.chars().rev() {
+        if TRAILING_PUNCTUATION.contains(&ch) {
+            end -= ch.len_utf8();
+        } else {
+            break;
+        }
+    }
+
+    // Add trimmed candidate first (highest priority) if it differs from original
+    if start < end && (start > 0 || end < candidate_len) {
+        candidates.push((candidate[start..end].to_string(), start..end));
+    }
+
+    // Extract markdown link destination: [title](path) or ](path) -> path
+    // This also handles bare (path) wrapping.
+    if let Some(captures) = MD_LINK_REGEX.captures(candidate) {
+        if let Some(link) = captures.get(1) {
+            let link_str = link.as_str().to_string();
+            let link_range = link.range();
+            // Avoid duplicate if punctuation trimming already found this
+            if !candidates.iter().any(|(s, _)| s == &link_str) {
+                candidates.push((link_str, link_range));
+            }
+        }
+    }
+
+    // Always include the raw candidate as fallback (lowest priority)
+    candidates.push((candidate.to_string(), 0..candidate_len));
+
     candidates
 }
 
@@ -816,7 +859,12 @@ fn surrounding_filename(
             found_start = true;
             break;
         }
-        if (ch == '"' || ch == '\'' || ch == '`') && !inside_quotes {
+        // Quote characters open a quoted region that is stripped from the
+        // returned filename. Backticks and parens are NOT treated this way —
+        // they are kept as part of the token so that downstream candidate
+        // generation (link_pattern_file_candidates) can trim them and produce
+        // a tight highlight range via make_range.
+        if (ch == '"' || ch == '\'') && !inside_quotes {
             found_start = true;
             inside_quotes = true;
             break;
@@ -849,7 +897,7 @@ fn surrounding_filename(
             found_end = true;
             break;
         }
-        if ch == '"' || ch == '\'' || ch == '`' {
+        if ch == '"' || ch == '\'' {
             // If we're inside quotes, we stop when we come across the next quote
             if inside_quotes {
                 found_end = true;
@@ -1569,66 +1617,98 @@ mod tests {
 
     #[test]
     fn test_link_pattern_file_candidates() {
+        // Full markdown link: [LinkTitle](link_file.txt)
+        // Trimmed strips [ and ), regex extracts link destination, raw is fallback
         let candidates: Vec<String> = link_pattern_file_candidates("[LinkTitle](link_file.txt)")
             .into_iter()
             .map(|(c, _)| c)
             .collect();
         assert_eq!(
             candidates,
-            vec!["[LinkTitle](link_file.txt)", "link_file.txt",]
+            vec![
+                "LinkTitle](link_file.txt",
+                "link_file.txt",
+                "[LinkTitle](link_file.txt)"
+            ]
         );
-        // Link title with spaces in it
+
+        // Link title with spaces (token starts mid-link)
         let candidates: Vec<String> = link_pattern_file_candidates("LinkTitle](link_file.txt)")
             .into_iter()
             .map(|(c, _)| c)
             .collect();
         assert_eq!(
             candidates,
-            vec!["LinkTitle](link_file.txt)", "link_file.txt",]
+            vec![
+                "LinkTitle](link_file.txt",
+                "link_file.txt",
+                "LinkTitle](link_file.txt)"
+            ]
         );
 
-        // Link with spaces
+        // Link with escaped spaces
         let candidates: Vec<String> = link_pattern_file_candidates("LinkTitle](link\\ _file.txt)")
             .into_iter()
             .map(|(c, _)| c)
             .collect();
-
         assert_eq!(
             candidates,
-            vec!["LinkTitle](link\\ _file.txt)", "link\\ _file.txt",]
+            vec![
+                "LinkTitle](link\\ _file.txt",
+                "link\\ _file.txt",
+                "LinkTitle](link\\ _file.txt)"
+            ]
         );
-        // Parentheses without preceding `]` should not extract inner content,
-        // to avoid matching function calls like `do_work(file2)` as file paths.
+
+        // Bare parentheses: (link_file.txt)
         let candidates: Vec<String> = link_pattern_file_candidates("(link_file.txt)")
             .into_iter()
             .map(|(c, _)| c)
             .collect();
-        assert_eq!(candidates, vec!["(link_file.txt)"]);
+        assert_eq!(candidates, vec!["link_file.txt", "(link_file.txt)"]);
 
-        let candidates: Vec<String> = link_pattern_file_candidates("do_work(file2);")
+        // Trailing paren only: link_file.txt)
+        let candidates: Vec<String> = link_pattern_file_candidates("link_file.txt)")
             .into_iter()
             .map(|(c, _)| c)
             .collect();
-        assert_eq!(candidates, vec!["do_work(file2);"]);
+        assert_eq!(candidates, vec!["link_file.txt", "link_file.txt)"]);
 
-        // Markdown links should still extract the path
-        let candidates: Vec<String> = link_pattern_file_candidates("](readme.md)")
+        // Trailing backtick only: link_file.txt`
+        let candidates: Vec<String> = link_pattern_file_candidates("link_file.txt`")
             .into_iter()
             .map(|(c, _)| c)
             .collect();
-        assert_eq!(candidates, vec!["](readme.md)", "readme.md"]);
+        assert_eq!(candidates, vec!["link_file.txt", "link_file.txt`"]);
 
-        // No nesting
+        // Wrapped in backticks: `link_file.txt`
+        let candidates: Vec<String> = link_pattern_file_candidates("`link_file.txt`")
+            .into_iter()
+            .map(|(c, _)| c)
+            .collect();
+        assert_eq!(candidates, vec!["link_file.txt", "`link_file.txt`"]);
+
+        // Trailing period (sentence ending): link_file.txt.
+        let candidates: Vec<String> = link_pattern_file_candidates("link_file.txt.")
+            .into_iter()
+            .map(|(c, _)| c)
+            .collect();
+        assert_eq!(candidates, vec!["link_file.txt", "link_file.txt."]);
+
+        // Nested parens - regex finds first (...) capturing inner content
         let candidates: Vec<String> =
             link_pattern_file_candidates("LinkTitle](link_(link_file)file.txt)")
                 .into_iter()
                 .map(|(c, _)| c)
                 .collect();
-
         assert_eq!(
             candidates,
-            vec!["LinkTitle](link_(link_file)file.txt)", "link_(link_file",]
-        )
+            vec![
+                "LinkTitle](link_(link_file)file.txt",
+                "link_(link_file",
+                "LinkTitle](link_(link_file)file.txt)"
+            ]
+        );
     }
 
     #[gpui::test]
@@ -1671,16 +1751,12 @@ mod tests {
             (" ˇ\"常\"", Some("常")),
             (" \"ˇ常\"", Some("常")),
             ("ˇ\"常\"", Some("常")),
-            // Path with row:column suffix
-            ("fiˇle.rs:83:1", Some("file.rs:83:1")),
-            ("file.rs:83ˇ:1 foo", Some("file.rs:83:1")),
-            ("file.rs:20ˇ:in bar", Some("file.rs:20:in")),
-            // Backtick delimiters
-            ("`fˇile.txt`", Some("file.txt")),
-            ("ˇ`file.txt`", Some("file.txt")),
-            ("`fˇile.txt` and more", Some("file.txt")),
-            // Backtick with row:col
-            ("`fiˇle.rs:83:1`", Some("file.rs:83:1")),
+            // Backticks (surrounding_filename returns the full token including backticks)
+            ("`fiˇle.txt`", Some("`file.txt`")),
+            ("open `fiˇle.txt` please", Some("`file.txt`")),
+            // Parentheses (surrounding_filename returns the full token including parens)
+            ("(fiˇle.txt)", Some("(file.txt)")),
+            ("open (fiˇle.txt) please", Some("(file.txt)")),
         ];
 
         for (input, expected) in test_cases {
@@ -1739,222 +1815,130 @@ mod tests {
             )
             .await;
 
+        // Base document with {ABS} placeholder for absolute path prefix.
+        // Each test case replaces a specific line to add cursor (ˇ) or highlight («»ˇ) markers.
         #[cfg(not(target_os = "windows"))]
-        cx.set_state(indoc! {"
-            You can't go to a file that does_not_exist.txt.
-            Go to file2.rs if you want.
-            Or go to ../dir/file2.rs if you want.
-            Or go to /root/dir/file2.rs if project is local.
-            Or go to /root/dir/file2 if this is a Rust file.ˇ
-            "});
+        const ABS: &str = "/root/dir";
         #[cfg(target_os = "windows")]
-        cx.set_state(indoc! {"
-            You can't go to a file that does_not_exist.txt.
-            Go to file2.rs if you want.
-            Or go to ../dir/file2.rs if you want.
-            Or go to C:/root/dir/file2.rs if project is local.
-            Or go to C:/root/dir/file2 if this is a Rust file.ˇ
-        "});
+        const ABS: &str = "C:/root/dir";
 
-        // File does not exist
-        #[cfg(not(target_os = "windows"))]
-        let screen_coord = cx.pixel_position(indoc! {"
-            You can't go to a file that dˇoes_not_exist.txt.
-            Go to file2.rs if you want.
-            Or go to ../dir/file2.rs if you want.
-            Or go to /root/dir/file2.rs if project is local.
-            Or go to /root/dir/file2 if this is a Rust file.
-        "});
-        #[cfg(target_os = "windows")]
-        let screen_coord = cx.pixel_position(indoc! {"
-            You can't go to a file that dˇoes_not_exist.txt.
-            Go to file2.rs if you want.
-            Or go to ../dir/file2.rs if you want.
-            Or go to C:/root/dir/file2.rs if project is local.
-            Or go to C:/root/dir/file2 if this is a Rust file.
-        "});
-        cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key());
-        // No highlight
-        cx.update_editor(|editor, window, cx| {
-            assert!(
-                editor
-                    .snapshot(window, cx)
-                    .text_highlight_ranges(HighlightKey::HoveredLinkState)
-                    .unwrap_or_default()
-                    .1
-                    .is_empty()
-            );
-        });
-
-        // Moving the mouse over a file that does exist should highlight it.
-        #[cfg(not(target_os = "windows"))]
-        let screen_coord = cx.pixel_position(indoc! {"
-            You can't go to a file that does_not_exist.txt.
-            Go to fˇile2.rs if you want.
-            Or go to ../dir/file2.rs if you want.
-            Or go to /root/dir/file2.rs if project is local.
-            Or go to /root/dir/file2 if this is a Rust file.
-        "});
-        #[cfg(target_os = "windows")]
-        let screen_coord = cx.pixel_position(indoc! {"
-            You can't go to a file that does_not_exist.txt.
-            Go to fˇile2.rs if you want.
-            Or go to ../dir/file2.rs if you want.
-            Or go to C:/root/dir/file2.rs if project is local.
-            Or go to C:/root/dir/file2 if this is a Rust file.
-        "});
-
-        cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key());
-        #[cfg(not(target_os = "windows"))]
-        cx.assert_editor_text_highlights(
-            HighlightKey::HoveredLinkState,
-            indoc! {"
-            You can't go to a file that does_not_exist.txt.
-            Go to «file2.rsˇ» if you want.
-            Or go to ../dir/file2.rs if you want.
-            Or go to /root/dir/file2.rs if project is local.
-            Or go to /root/dir/file2 if this is a Rust file.
-        "},
-        );
-        #[cfg(target_os = "windows")]
-        cx.assert_editor_text_highlights(
-            HighlightKey::HoveredLinkState,
-            indoc! {"
-            You can't go to a file that does_not_exist.txt.
-            Go to «file2.rsˇ» if you want.
-            Or go to ../dir/file2.rs if you want.
-            Or go to C:/root/dir/file2.rs if project is local.
-            Or go to C:/root/dir/file2 if this is a Rust file.
-        "},
+        let base = format!(
+            "\
+You can't go to a file that does_not_exist.txt.
+Go to file2.rs if you want.
+Or go to ../dir/file2.rs if you want.
+Or go to {ABS}/file2.rs if project is local.
+Or go to {ABS}/file2 if this is a Rust file.
+Or `file2.rs` in backticks.
+Or (file2.rs) in parens.
+Or [link](file2.rs) markdown style.
+A file (named file2.rs) in prose.
+Read with `cat file2.rs` command.
+Sentence ending file2.rs.
+"
         );
 
-        // Moving the mouse over a relative path that does exist should highlight it
-        #[cfg(not(target_os = "windows"))]
-        let screen_coord = cx.pixel_position(indoc! {"
-            You can't go to a file that does_not_exist.txt.
-            Go to file2.rs if you want.
-            Or go to ../dir/fˇile2.rs if you want.
-            Or go to /root/dir/file2.rs if project is local.
-            Or go to /root/dir/file2 if this is a Rust file.
-        "});
-        #[cfg(target_os = "windows")]
-        let screen_coord = cx.pixel_position(indoc! {"
-            You can't go to a file that does_not_exist.txt.
-            Go to file2.rs if you want.
-            Or go to ../dir/fˇile2.rs if you want.
-            Or go to C:/root/dir/file2.rs if project is local.
-            Or go to C:/root/dir/file2 if this is a Rust file.
-        "});
+        cx.set_state(&format!("{base}ˇ"));
 
-        cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key());
-        #[cfg(not(target_os = "windows"))]
-        cx.assert_editor_text_highlights(
-            HighlightKey::HoveredLinkState,
-            indoc! {"
-            You can't go to a file that does_not_exist.txt.
-            Go to file2.rs if you want.
-            Or go to «../dir/file2.rsˇ» if you want.
-            Or go to /root/dir/file2.rs if project is local.
-            Or go to /root/dir/file2 if this is a Rust file.
-        "},
+        // Test cases: (original_line, cursor_line, highlight_line)
+        // - cursor_line: the line with ˇ to position the mouse
+        // - highlight_line: None = expect no highlight, Some(...) = expect this highlight
+        let test_cases: &[(&str, &str, Option<&str>)] = &[
+            // File does not exist - no highlight
+            ("does_not_exist.txt", "dˇoes_not_exist.txt", None),
+            // Simple filename
+            (
+                "Go to file2.rs if",
+                "Go to fˇile2.rs if",
+                Some("Go to «file2.rsˇ» if"),
+            ),
+            // Relative path
+            (
+                "Or go to ../dir/file2.rs if",
+                "Or go to ../dir/fˇile2.rs if",
+                Some("Or go to «../dir/file2.rsˇ» if"),
+            ),
+            // Absolute path
+            (
+                &format!("Or go to {ABS}/file2.rs if"),
+                &format!("Or go to {ABS}/fiˇle2.rs if"),
+                Some(&format!("Or go to «{ABS}/file2.rsˇ» if")),
+            ),
+            // Path without extension (language suffix added)
+            (
+                &format!("Or go to {ABS}/file2 if"),
+                &format!("Or go to {ABS}/fiˇle2 if"),
+                Some(&format!("Or go to «{ABS}/file2ˇ» if")),
+            ),
+            // Backticks
+            (
+                "Or `file2.rs` in backticks",
+                "Or `fiˇle2.rs` in backticks",
+                Some("Or `«file2.rsˇ»` in backticks"),
+            ),
+            // Parentheses
+            (
+                "Or (file2.rs) in parens",
+                "Or (fiˇle2.rs) in parens",
+                Some("Or («file2.rsˇ») in parens"),
+            ),
+            // Markdown link
+            (
+                "Or [link](file2.rs) markdown",
+                "Or [link](fiˇle2.rs) markdown",
+                Some("Or [link](«file2.rsˇ») markdown"),
+            ),
+            // Partial wrapper: trailing paren in prose like "(named file2.rs)"
+            (
+                "A file (named file2.rs) in",
+                "A file (named fiˇle2.rs) in",
+                Some("A file (named «file2.rsˇ») in"),
+            ),
+            // Partial wrapper: inside code span like "`cat file2.rs`"
+            (
+                "Read with `cat file2.rs` command",
+                "Read with `cat fiˇle2.rs` command",
+                Some("Read with `cat «file2.rsˇ»` command"),
+            ),
+            // Trailing period at end of sentence
+            (
+                "Sentence ending file2.rs.",
+                "Sentence ending fiˇle2.rs.",
+                Some("Sentence ending «file2.rsˇ»."),
+            ),
+        ];
+
+        for (original, cursor_version, highlight_version) in test_cases {
+            let position_text = base.replace(original, cursor_version);
+            let screen_coord = cx.pixel_position(&position_text);
+            cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key());
+
+            if let Some(highlight) = highlight_version {
+                let expected = base.replace(original, highlight);
+                cx.assert_editor_text_highlights(HighlightKey::HoveredLinkState, &expected);
+            } else {
+                // Expect no highlight
+                cx.update_editor(|editor, window, cx| {
+                    assert!(
+                        editor
+                            .snapshot(window, cx)
+                            .text_highlight_ranges(HighlightKey::HoveredLinkState)
+                            .unwrap_or_default()
+                            .1
+                            .is_empty(),
+                        "Expected no highlight for cursor at: {}",
+                        cursor_version
+                    );
+                });
+            }
+        }
+
+        // Test click navigation on markdown link
+        let position_text = base.replace(
+            "Or [link](file2.rs) markdown",
+            "Or [link](fiˇle2.rs) markdown",
         );
-        #[cfg(target_os = "windows")]
-        cx.assert_editor_text_highlights(
-            HighlightKey::HoveredLinkState,
-            indoc! {"
-            You can't go to a file that does_not_exist.txt.
-            Go to file2.rs if you want.
-            Or go to «../dir/file2.rsˇ» if you want.
-            Or go to C:/root/dir/file2.rs if project is local.
-            Or go to C:/root/dir/file2 if this is a Rust file.
-        "},
-        );
-
-        // Moving the mouse over an absolute path that does exist should highlight it
-        #[cfg(not(target_os = "windows"))]
-        let screen_coord = cx.pixel_position(indoc! {"
-            You can't go to a file that does_not_exist.txt.
-            Go to file2.rs if you want.
-            Or go to ../dir/file2.rs if you want.
-            Or go to /root/diˇr/file2.rs if project is local.
-            Or go to /root/dir/file2 if this is a Rust file.
-        "});
-
-        #[cfg(target_os = "windows")]
-        let screen_coord = cx.pixel_position(indoc! {"
-            You can't go to a file that does_not_exist.txt.
-            Go to file2.rs if you want.
-            Or go to ../dir/file2.rs if you want.
-            Or go to C:/root/diˇr/file2.rs if project is local.
-            Or go to C:/root/dir/file2 if this is a Rust file.
-        "});
-
-        cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key());
-        #[cfg(not(target_os = "windows"))]
-        cx.assert_editor_text_highlights(
-            HighlightKey::HoveredLinkState,
-            indoc! {"
-            You can't go to a file that does_not_exist.txt.
-            Go to file2.rs if you want.
-            Or go to ../dir/file2.rs if you want.
-            Or go to «/root/dir/file2.rsˇ» if project is local.
-            Or go to /root/dir/file2 if this is a Rust file.
-        "},
-        );
-        #[cfg(target_os = "windows")]
-        cx.assert_editor_text_highlights(
-            HighlightKey::HoveredLinkState,
-            indoc! {"
-            You can't go to a file that does_not_exist.txt.
-            Go to file2.rs if you want.
-            Or go to ../dir/file2.rs if you want.
-            Or go to «C:/root/dir/file2.rsˇ» if project is local.
-            Or go to C:/root/dir/file2 if this is a Rust file.
-        "},
-        );
-
-        // Moving the mouse over a path that exists, if we add the language-specific suffix, it should highlight it
-        #[cfg(not(target_os = "windows"))]
-        let screen_coord = cx.pixel_position(indoc! {"
-            You can't go to a file that does_not_exist.txt.
-            Go to file2.rs if you want.
-            Or go to ../dir/file2.rs if you want.
-            Or go to /root/dir/file2.rs if project is local.
-            Or go to /root/diˇr/file2 if this is a Rust file.
-        "});
-        #[cfg(target_os = "windows")]
-        let screen_coord = cx.pixel_position(indoc! {"
-            You can't go to a file that does_not_exist.txt.
-            Go to file2.rs if you want.
-            Or go to ../dir/file2.rs if you want.
-            Or go to C:/root/dir/file2.rs if project is local.
-            Or go to C:/root/diˇr/file2 if this is a Rust file.
-        "});
-
-        cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key());
-        #[cfg(not(target_os = "windows"))]
-        cx.assert_editor_text_highlights(
-            HighlightKey::HoveredLinkState,
-            indoc! {"
-            You can't go to a file that does_not_exist.txt.
-            Go to file2.rs if you want.
-            Or go to ../dir/file2.rs if you want.
-            Or go to /root/dir/file2.rs if project is local.
-            Or go to «/root/dir/file2ˇ» if this is a Rust file.
-        "},
-        );
-        #[cfg(target_os = "windows")]
-        cx.assert_editor_text_highlights(
-            HighlightKey::HoveredLinkState,
-            indoc! {"
-            You can't go to a file that does_not_exist.txt.
-            Go to file2.rs if you want.
-            Or go to ../dir/file2.rs if you want.
-            Or go to C:/root/dir/file2.rs if project is local.
-            Or go to «C:/root/dir/file2ˇ» if this is a Rust file.
-        "},
-        );
-
+        let screen_coord = cx.pixel_position(&position_text);
         cx.simulate_click(screen_coord, Modifiers::secondary_key());
 
         cx.update_workspace(|workspace, _, cx| assert_eq!(workspace.items(cx).count(), 2));

From ddb847d03af4a45d987dc0405f7930922656fdfd Mon Sep 17 00:00:00 2001
From: Oleksiy Syvokon <oleksiy@zed.dev>
Date: Thu, 21 May 2026 06:59:50 +0300
Subject: [PATCH 075/105] Fix race condition in OpenPathDelegate (#57290)

Directory entries and string matches can briefly go out of sync during
async updates. When that happens, we used to highlight the wrong
substring (best case), or panic if the offset happens to be mid-Unicode
or out of range.

After this change, we fall back to rendering a row without highlights
when matches are out of sync. The highlight will be shown on the next
frame. This is a rare condition and the easiest fix, so should be
acceptable.

Closes FR-11

Release Notes:

- Fixed rare panic in the open path dialog
---
 .../open_path_prompt/src/open_path_prompt.rs  | 24 +++++++++----
 .../src/open_path_prompt_tests.rs             | 36 ++++++++++++++++++-
 2 files changed, 52 insertions(+), 8 deletions(-)

diff --git a/crates/open_path_prompt/src/open_path_prompt.rs b/crates/open_path_prompt/src/open_path_prompt.rs
index 607dfb13e4f..8cfcb115cd8 100644
--- a/crates/open_path_prompt/src/open_path_prompt.rs
+++ b/crates/open_path_prompt/src/open_path_prompt.rs
@@ -709,26 +709,36 @@ impl PickerDelegate for OpenPathDelegate {
     ) -> Option<Self::ListItem> {
         let settings = FileFinderSettings::get_global(cx);
         let candidate = self.get_entry(ix)?;
-        let mut match_positions = match &self.directory_state {
-            DirectoryState::List { .. } => self.string_matches.get(ix)?.positions.clone(),
+        let string_match = match &self.directory_state {
+            DirectoryState::List { .. } => self.string_matches.get(ix),
             DirectoryState::Create { user_input, .. } => {
                 if let Some(user_input) = user_input {
                     if !user_input.exists || !user_input.is_dir {
                         if ix == 0 {
-                            Vec::new()
+                            None
                         } else {
-                            self.string_matches.get(ix - 1)?.positions.clone()
+                            self.string_matches.get(ix - 1)
                         }
                     } else {
-                        self.string_matches.get(ix)?.positions.clone()
+                        self.string_matches.get(ix)
                     }
                 } else {
-                    self.string_matches.get(ix)?.positions.clone()
+                    self.string_matches.get(ix)
                 }
             }
-            DirectoryState::None { .. } => Vec::new(),
+            DirectoryState::None { .. } => None,
         };
 
+        // Directory entries and string matches can briefly go out of sync during
+        // async updates. When that happens, render the row without highlights.
+        let mut match_positions = string_match
+            .filter(|string_match| {
+                string_match.candidate_id == candidate.path.id
+                    && string_match.string == candidate.path.string
+            })
+            .map(|string_match| string_match.positions.clone())
+            .unwrap_or_default();
+
         let is_current_dir_candidate = candidate.path.string == self.current_dir();
 
         let file_icon = maybe!({
diff --git a/crates/open_path_prompt/src/open_path_prompt_tests.rs b/crates/open_path_prompt/src/open_path_prompt_tests.rs
index 7d359dbf176..d89b657860e 100644
--- a/crates/open_path_prompt/src/open_path_prompt_tests.rs
+++ b/crates/open_path_prompt/src/open_path_prompt_tests.rs
@@ -1,5 +1,6 @@
 use std::sync::Arc;
 
+use fuzzy::{StringMatch, StringMatchCandidate};
 use gpui::{AppContext, Entity, TestAppContext, VisualTestContext};
 use picker::{Picker, PickerDelegate};
 use project::Project;
@@ -8,7 +9,7 @@ use ui::rems;
 use util::path;
 use workspace::{AppState, MultiWorkspace};
 
-use crate::OpenPathDelegate;
+use crate::{CandidateInfo, DirectoryState, OpenPathDelegate};
 
 #[gpui::test]
 async fn test_open_path_prompt(cx: &mut TestAppContext) {
@@ -372,6 +373,39 @@ async fn test_new_path_prompt(cx: &mut TestAppContext) {
     assert_eq!(collect_match_candidates(&picker, cx), vec!["dir1"]);
 }
 
+#[gpui::test]
+async fn test_open_path_prompt_panics_with_stale_highlight_positions(cx: &mut TestAppContext) {
+    let app_state = init_test(cx);
+    app_state
+        .fs
+        .as_fake()
+        .insert_tree(path!("/root"), json!({}))
+        .await;
+
+    let project = Project::test(app_state.fs.clone(), [path!("/root").as_ref()], cx).await;
+    let (picker, cx) = build_open_path_prompt(project, false, false, cx);
+
+    picker.update_in(cx, |picker, window, cx| {
+        picker.delegate.prompt_root = "/".to_string();
+        picker.delegate.directory_state = DirectoryState::List {
+            parent_path: picker.delegate.prompt_root.clone(),
+            entries: vec![CandidateInfo {
+                path: StringMatchCandidate::new(0, "éclair"),
+                is_dir: false,
+            }],
+            error: None,
+        };
+        picker.delegate.string_matches = vec![StringMatch {
+            candidate_id: 0,
+            score: 0.0,
+            positions: vec![1],
+            string: "ab".to_string(),
+        }];
+
+        picker.delegate.render_match(0, false, window, cx);
+    });
+}
+
 #[gpui::test]
 async fn test_open_path_prompt_with_show_hidden(cx: &mut TestAppContext) {
     let app_state = init_test(cx);

From 7f7c21536e080a24861289aabccd99d78808a84e Mon Sep 17 00:00:00 2001
From: Oleksiy Syvokon <oleksiy@zed.dev>
Date: Thu, 21 May 2026 07:01:28 +0300
Subject: [PATCH 076/105] ui: Don't panic on invalid highlight indices in
 `HighlightedLabel` (#57291)

HighlightedLabel would crash the application if any provided highlight
index was invalid. In theory, this should never happen. In practice,
this can happen due to race conditions at call sites.

After this change, we only panic in debug builds. In release builds, we
log an error and return a label with no highlights. The error message
includes the call site so that it's easier to fix the root cause.

Related to #57290

Part of FR-11.

Release Notes:

- N/A
---
 Cargo.lock                                     |  1 +
 crates/ui/Cargo.toml                           |  4 ++++
 .../src/components/label/highlighted_label.rs  | 18 +++++++++++++-----
 3 files changed, 18 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ad760e911e2..73206015b40 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -19197,6 +19197,7 @@ dependencies = [
  "gpui_util",
  "icons",
  "itertools 0.14.0",
+ "log",
  "menu",
  "num-format",
  "schemars 1.0.4",
diff --git a/crates/ui/Cargo.toml b/crates/ui/Cargo.toml
index 97469cae36c..7999a300648 100644
--- a/crates/ui/Cargo.toml
+++ b/crates/ui/Cargo.toml
@@ -20,6 +20,7 @@ gpui.workspace = true
 gpui_macros.workspace = true
 icons.workspace = true
 itertools.workspace = true
+log.workspace = true
 menu.workspace = true
 num-format.workspace = true
 schemars.workspace = true
@@ -36,5 +37,8 @@ windows.workspace = true
 [dev-dependencies]
 gpui = { workspace = true, features = ["test-support"] }
 
+[package.metadata.cargo-machete]
+ignored = ["log"]
+
 [features]
 default = []
diff --git a/crates/ui/src/components/label/highlighted_label.rs b/crates/ui/src/components/label/highlighted_label.rs
index 73e03f82dfd..6d5b1d5645a 100644
--- a/crates/ui/src/components/label/highlighted_label.rs
+++ b/crates/ui/src/components/label/highlighted_label.rs
@@ -1,6 +1,7 @@
 use std::ops::Range;
 
 use gpui::{FontWeight, HighlightStyle, StyleRefinement, StyledText};
+use gpui_util::debug_panic;
 
 use crate::{LabelCommon, LabelLike, LabelSize, LineHeightStyle, prelude::*};
 
@@ -14,14 +15,21 @@ pub struct HighlightedLabel {
 impl HighlightedLabel {
     /// Constructs a label with the given characters highlighted.
     /// Characters are identified by UTF-8 byte position.
-    pub fn new(label: impl Into<SharedString>, highlight_indices: Vec<usize>) -> Self {
+    #[track_caller]
+    pub fn new(label: impl Into<SharedString>, mut highlight_indices: Vec<usize>) -> Self {
         let label = label.into();
-        for &run in &highlight_indices {
-            assert!(
-                label.is_char_boundary(run),
-                "highlight index {run} is not a valid UTF-8 boundary"
+
+        if let Some(index) = highlight_indices
+            .iter()
+            .find(|&i| !label.is_char_boundary(*i))
+        {
+            let location = std::panic::Location::caller();
+            debug_panic!(
+                "highlight index {index} is not a valid UTF-8 boundary (called from {location})"
             );
+            highlight_indices.clear();
         }
+
         Self {
             base: LabelLike::new(),
             label,

From 4558d14cf849786b914eb1cd0196c375d4e9cf71 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=20Houl=C3=A9?=
 <13155277+tomhoule@users.noreply.github.com>
Date: Thu, 21 May 2026 09:37:59 +0200
Subject: [PATCH 077/105] google_ai: Support Gemini 3.5 Flash (#57299)

Implements the [official upgrade
instructions](https://ai.google.dev/gemini-api/docs/whats-new-gemini-3.5#migrate-from-3-flash-preview)
for Gemini 3.5 Flash, and adds BYOK support.

The changes about thinking_level and temperature apply to our situation,
but they are only recommendations, and we have to support older models,
so I preferred not trying to force the preferred / remove the
discouraged parameters for now.

`temperature` becomes optional - we don't fill in a default anymore,
since passing it is now discouraged.

This commit also adds support for `thinking_level`, since it is now
preferred to `thinking_budget`.

`FunctionCall` and `FunctionResponse` now support passing an `id` to
properly maintain chain-of-thought preservation and match execution IDs
across turns. When resolving incoming tool uses, the mapper prefers the
execution ID returned by Gemini, falling back to sequential naming in
other scenarios.

Release Notes:

- Added support for Gemini 3.5 Flash in the Google AI model provider.
---
 crates/google_ai/src/completion.rs | 39 ++++++++++++++++++++++++++----
 crates/google_ai/src/google_ai.rs  | 32 +++++++++++++++++++++++-
 2 files changed, 65 insertions(+), 6 deletions(-)

diff --git a/crates/google_ai/src/completion.rs b/crates/google_ai/src/completion.rs
index b546682c552..b96679cfbc1 100644
--- a/crates/google_ai/src/completion.rs
+++ b/crates/google_ai/src/completion.rs
@@ -65,6 +65,7 @@ pub fn into_google(
                         function_call: crate::FunctionCall {
                             name: tool_use.name.to_string(),
                             args: tool_use.input,
+                            id: Some(tool_use.id.to_string()),
                         },
                         thought_signature,
                     })]
@@ -99,6 +100,7 @@ pub fn into_google(
                             response: serde_json::json!({
                                 "output": output
                             }),
+                            id: Some(tool_result.tool_use_id.to_string()),
                         },
                     })];
                     parts.extend(images.into_iter().map(Part::InlineDataPart));
@@ -147,10 +149,30 @@ pub fn into_google(
             candidate_count: Some(1),
             stop_sequences: Some(request.stop),
             max_output_tokens: None,
-            temperature: request.temperature.map(|t| t as f64).or(Some(1.0)),
+            temperature: request.temperature.map(|t| t as f64),
             thinking_config: match (request.thinking_allowed, mode) {
                 (true, GoogleModelMode::Thinking { budget_tokens }) => {
-                    budget_tokens.map(|thinking_budget| ThinkingConfig { thinking_budget })
+                    let effort = request.thinking_effort.as_deref().map(|s| s.to_lowercase());
+                    let thinking_level = match effort.as_deref() {
+                        Some("high") => Some(crate::ThinkingLevel::High),
+                        Some("medium") => Some(crate::ThinkingLevel::Medium),
+                        Some("low") => Some(crate::ThinkingLevel::Low),
+                        Some("minimal") => Some(crate::ThinkingLevel::Minimal),
+                        _ => None,
+                    };
+
+                    Some(ThinkingConfig {
+                        thinking_budget: budget_tokens,
+                        thinking_level,
+                    })
+                    .filter(
+                        |ThinkingConfig {
+                             thinking_budget,
+                             thinking_level,
+                         }| {
+                            thinking_level.is_some() || thinking_budget.is_some()
+                        },
+                    )
                 }
                 _ => None,
             },
@@ -272,10 +294,14 @@ impl GoogleEventMapper {
                         Part::FunctionCallPart(function_call_part) => {
                             wants_to_use_tool = true;
                             let name: Arc<str> = function_call_part.function_call.name.into();
-                            let next_tool_id =
-                                TOOL_CALL_COUNTER.fetch_add(1, atomic::Ordering::SeqCst);
                             let id: LanguageModelToolUseId =
-                                format!("{}-{}", name, next_tool_id).into();
+                                if let Some(ref call_id) = function_call_part.function_call.id {
+                                    call_id.clone().into()
+                                } else {
+                                    let next_tool_id =
+                                        TOOL_CALL_COUNTER.fetch_add(1, atomic::Ordering::SeqCst);
+                                    format!("{}-{}", name, next_tool_id).into()
+                                };
 
                             // Normalize empty string signatures to None
                             let thought_signature = function_call_part
@@ -370,6 +396,7 @@ mod tests {
                         function_call: FunctionCall {
                             name: "test_function".to_string(),
                             args: json!({"arg": "value"}),
+                            id: None,
                         },
                         thought_signature: Some("test_signature_123".to_string()),
                     })],
@@ -410,6 +437,7 @@ mod tests {
                         function_call: FunctionCall {
                             name: "test_function".to_string(),
                             args: json!({"arg": "value"}),
+                            id: None,
                         },
                         thought_signature: None,
                     })],
@@ -446,6 +474,7 @@ mod tests {
                         function_call: FunctionCall {
                             name: "test_function".to_string(),
                             args: json!({"arg": "value"}),
+                            id: None,
                         },
                         thought_signature: Some("".to_string()),
                     })],
diff --git a/crates/google_ai/src/google_ai.rs b/crates/google_ai/src/google_ai.rs
index 184147cdb4c..305f43ab3a3 100644
--- a/crates/google_ai/src/google_ai.rs
+++ b/crates/google_ai/src/google_ai.rs
@@ -264,7 +264,19 @@ pub struct UsageMetadata {
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ThinkingConfig {
-    pub thinking_budget: u32,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub thinking_budget: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub thinking_level: Option<ThinkingLevel>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "UPPERCASE")]
+pub enum ThinkingLevel {
+    Minimal,
+    Low,
+    Medium,
+    High,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
@@ -352,12 +364,16 @@ pub struct SafetyRating {
 pub struct FunctionCall {
     pub name: String,
     pub args: serde_json::Value,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct FunctionResponse {
     pub name: String,
     pub response: serde_json::Value,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -469,6 +485,8 @@ pub enum Model {
     Gemini31FlashLite,
     #[serde(rename = "gemini-3-flash-preview")]
     Gemini3Flash,
+    #[serde(rename = "gemini-3.5-flash")]
+    Gemini35Flash,
     #[serde(rename = "gemini-3.1-pro-preview", alias = "gemini-3-pro-preview")]
     Gemini31Pro,
     #[serde(rename = "custom")]
@@ -494,6 +512,7 @@ impl Model {
             Self::Gemini25Pro => "gemini-2.5-pro",
             Self::Gemini31FlashLite => "gemini-3.1-flash-lite",
             Self::Gemini3Flash => "gemini-3-flash-preview",
+            Self::Gemini35Flash => "gemini-3.5-flash",
             Self::Gemini31Pro => "gemini-3.1-pro-preview",
             Self::Custom { name, .. } => name,
         }
@@ -505,6 +524,7 @@ impl Model {
             Self::Gemini25Pro => "gemini-2.5-pro",
             Self::Gemini31FlashLite => "gemini-3.1-flash-lite",
             Self::Gemini3Flash => "gemini-3-flash-preview",
+            Self::Gemini35Flash => "gemini-3.5-flash",
             Self::Gemini31Pro => "gemini-3.1-pro-preview",
             Self::Custom { name, .. } => name,
         }
@@ -517,6 +537,7 @@ impl Model {
             Self::Gemini25Pro => "Gemini 2.5 Pro",
             Self::Gemini31FlashLite => "Gemini 3.1 Flash Lite",
             Self::Gemini3Flash => "Gemini 3 Flash",
+            Self::Gemini35Flash => "Gemini 3.5 Flash",
             Self::Gemini31Pro => "Gemini 3.1 Pro",
             Self::Custom {
                 name, display_name, ..
@@ -531,6 +552,7 @@ impl Model {
             | Self::Gemini25Pro
             | Self::Gemini31FlashLite
             | Self::Gemini3Flash
+            | Self::Gemini35Flash
             | Self::Gemini31Pro => 1_048_576,
             Self::Custom { max_tokens, .. } => *max_tokens,
         }
@@ -543,6 +565,7 @@ impl Model {
             | Model::Gemini25Pro
             | Model::Gemini31FlashLite
             | Model::Gemini3Flash
+            | Model::Gemini35Flash
             | Model::Gemini31Pro => Some(65_536),
             Model::Custom { .. } => None,
         }
@@ -567,6 +590,9 @@ impl Model {
             }
             Self::Gemini3Flash => GoogleModelMode::Default,
             Self::Gemini31FlashLite => GoogleModelMode::Default,
+            Self::Gemini35Flash => GoogleModelMode::Thinking {
+                budget_tokens: None,
+            },
             Self::Gemini31Pro => GoogleModelMode::Thinking {
                 budget_tokens: None,
             },
@@ -592,6 +618,7 @@ mod tests {
             function_call: FunctionCall {
                 name: "test_function".to_string(),
                 args: json!({"arg": "value"}),
+                id: None,
             },
             thought_signature: Some("test_signature".to_string()),
         };
@@ -609,6 +636,7 @@ mod tests {
             function_call: FunctionCall {
                 name: "test_function".to_string(),
                 args: json!({"arg": "value"}),
+                id: None,
             },
             thought_signature: None,
         };
@@ -658,6 +686,7 @@ mod tests {
             function_call: FunctionCall {
                 name: "test_function".to_string(),
                 args: json!({"arg": "value", "nested": {"key": "val"}}),
+                id: None,
             },
             thought_signature: Some("round_trip_signature".to_string()),
         };
@@ -676,6 +705,7 @@ mod tests {
             function_call: FunctionCall {
                 name: "test_function".to_string(),
                 args: json!({"arg": "value"}),
+                id: None,
             },
             thought_signature: Some("".to_string()),
         };

From c84c22dab5c16a53d5e62ca538d86730e8bac143 Mon Sep 17 00:00:00 2001
From: Finn Evers <finn@zed.dev>
Date: Thu, 21 May 2026 10:32:23 +0200
Subject: [PATCH 078/105] Deprecate and migrate ACP extensions (#57133)

Self-Review Checklist:

- [X] I've reviewed my own diff for quality, security, and reliability
- [N/A] Unsafe blocks (if any) have justifying comments
- [X] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [ ] Tests cover the new/changed behavior
- [X] Performance impact has been considered and is acceptable

Release Notes:

- Removed support for ACP extensions. Installed ACP extensions will be
migrated to use the ACP servers as provided by the ACP registry instead.

---------

Co-authored-by: Ben Brandt <benjamin.j.brandt@gmail.com>
Co-authored-by: Marshall Bowers <git@maxdeviant.com>
---
 Cargo.lock                                    |   1 -
 crates/agent_servers/src/custom.rs            | 116 +---
 crates/agent_ui/src/agent_configuration.rs    |  21 -
 crates/agent_ui/src/agent_panel.rs            |  55 +-
 crates/agent_ui/src/agent_registry_ui.rs      |   7 -
 crates/cloud_api_types/src/extension.rs       |   3 +
 crates/extension/src/extension_manifest.rs    |  39 +-
 crates/extension_cli/src/main.rs              |  15 -
 .../extension_compilation_benchmark.rs        |   1 -
 .../extension_host/src/capability_granter.rs  |   1 -
 crates/extension_host/src/extension_host.rs   |  47 +-
 .../src/extension_store_test.rs               |   3 -
 crates/extensions_ui/Cargo.toml               |   1 -
 crates/extensions_ui/src/extensions_ui.rs     |  82 +--
 crates/project/src/agent_server_store.rs      | 600 ++----------------
 .../tests/integration/ext_agent_tests.rs      | 224 -------
 .../integration/extension_agent_tests.rs      | 332 ----------
 .../tests/integration/project_tests.rs        |   2 -
 crates/settings_content/src/agent.rs          |  42 +-
 crates/zed_actions/src/lib.rs                 |   1 -
 20 files changed, 134 insertions(+), 1459 deletions(-)
 delete mode 100644 crates/project/tests/integration/ext_agent_tests.rs
 delete mode 100644 crates/project/tests/integration/extension_agent_tests.rs

diff --git a/Cargo.lock b/Cargo.lock
index 73206015b40..2ccdca4d6cc 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6166,7 +6166,6 @@ name = "extensions_ui"
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "client",
  "cloud_api_types",
  "collections",
  "db",
diff --git a/crates/agent_servers/src/custom.rs b/crates/agent_servers/src/custom.rs
index b3574f6e81a..77c9595f171 100644
--- a/crates/agent_servers/src/custom.rs
+++ b/crates/agent_servers/src/custom.rs
@@ -88,22 +88,18 @@ impl AgentServer for CustomAgentServer {
         let config_id = config_id.to_string();
         let value_id = value_id.to_string();
 
-        update_settings_file(fs, cx, move |settings, cx| {
+        update_settings_file(fs, cx, move |settings, _cx| {
             let settings = settings
                 .agent_servers
                 .get_or_insert_default()
                 .entry(agent_id.0.to_string())
-                .or_insert_with(|| default_settings_for_agent(agent_id, cx));
+                .or_insert_with(default_settings_for_agent);
 
             match settings {
                 settings::CustomAgentServerSettings::Custom {
                     favorite_config_option_values,
                     ..
                 }
-                | settings::CustomAgentServerSettings::Extension {
-                    favorite_config_option_values,
-                    ..
-                }
                 | settings::CustomAgentServerSettings::Registry {
                     favorite_config_option_values,
                     ..
@@ -129,16 +125,15 @@ impl AgentServer for CustomAgentServer {
 
     fn set_default_mode(&self, mode_id: Option<acp::SessionModeId>, fs: Arc<dyn Fs>, cx: &mut App) {
         let agent_id = self.agent_id();
-        update_settings_file(fs, cx, move |settings, cx| {
+        update_settings_file(fs, cx, move |settings, _cx| {
             let settings = settings
                 .agent_servers
                 .get_or_insert_default()
                 .entry(agent_id.0.to_string())
-                .or_insert_with(|| default_settings_for_agent(agent_id, cx));
+                .or_insert_with(default_settings_for_agent);
 
             match settings {
                 settings::CustomAgentServerSettings::Custom { default_mode, .. }
-                | settings::CustomAgentServerSettings::Extension { default_mode, .. }
                 | settings::CustomAgentServerSettings::Registry { default_mode, .. } => {
                     *default_mode = mode_id.map(|m| m.to_string());
                 }
@@ -161,16 +156,15 @@ impl AgentServer for CustomAgentServer {
 
     fn set_default_model(&self, model_id: Option<acp::ModelId>, fs: Arc<dyn Fs>, cx: &mut App) {
         let agent_id = self.agent_id();
-        update_settings_file(fs, cx, move |settings, cx| {
+        update_settings_file(fs, cx, move |settings, _cx| {
             let settings = settings
                 .agent_servers
                 .get_or_insert_default()
                 .entry(agent_id.0.to_string())
-                .or_insert_with(|| default_settings_for_agent(agent_id, cx));
+                .or_insert_with(default_settings_for_agent);
 
             match settings {
                 settings::CustomAgentServerSettings::Custom { default_model, .. }
-                | settings::CustomAgentServerSettings::Extension { default_model, .. }
                 | settings::CustomAgentServerSettings::Registry { default_model, .. } => {
                     *default_model = model_id.map(|m| m.to_string());
                 }
@@ -205,20 +199,17 @@ impl AgentServer for CustomAgentServer {
         cx: &App,
     ) {
         let agent_id = self.agent_id();
-        update_settings_file(fs, cx, move |settings, cx| {
+        update_settings_file(fs, cx, move |settings, _cx| {
             let settings = settings
                 .agent_servers
                 .get_or_insert_default()
                 .entry(agent_id.0.to_string())
-                .or_insert_with(|| default_settings_for_agent(agent_id, cx));
+                .or_insert_with(default_settings_for_agent);
 
             let favorite_models = match settings {
                 settings::CustomAgentServerSettings::Custom {
                     favorite_models, ..
                 }
-                | settings::CustomAgentServerSettings::Extension {
-                    favorite_models, ..
-                }
                 | settings::CustomAgentServerSettings::Registry {
                     favorite_models, ..
                 } => favorite_models,
@@ -258,22 +249,18 @@ impl AgentServer for CustomAgentServer {
         let agent_id = self.agent_id();
         let config_id = config_id.to_string();
         let value_id = value_id.map(|s| s.to_string());
-        update_settings_file(fs, cx, move |settings, cx| {
+        update_settings_file(fs, cx, move |settings, _cx| {
             let settings = settings
                 .agent_servers
                 .get_or_insert_default()
                 .entry(agent_id.0.to_string())
-                .or_insert_with(|| default_settings_for_agent(agent_id, cx));
+                .or_insert_with(default_settings_for_agent);
 
             match settings {
                 settings::CustomAgentServerSettings::Custom {
                     default_config_options,
                     ..
                 }
-                | settings::CustomAgentServerSettings::Extension {
-                    default_config_options,
-                    ..
-                }
                 | settings::CustomAgentServerSettings::Registry {
                     default_config_options,
                     ..
@@ -307,10 +294,6 @@ impl AgentServer for CustomAgentServer {
                         default_config_options,
                         ..
                     }
-                    | project::agent_server_store::CustomAgentServerSettings::Extension {
-                        default_config_options,
-                        ..
-                    }
                     | project::agent_server_store::CustomAgentServerSettings::Registry {
                         default_config_options,
                         ..
@@ -422,28 +405,14 @@ fn is_registry_agent(agent_id: impl Into<AgentId>, cx: &App) -> bool {
     is_in_registry || is_settings_registry
 }
 
-fn default_settings_for_agent(
-    agent_id: impl Into<AgentId>,
-    cx: &App,
-) -> settings::CustomAgentServerSettings {
-    if is_registry_agent(agent_id, cx) {
-        settings::CustomAgentServerSettings::Registry {
-            default_model: None,
-            default_mode: None,
-            env: Default::default(),
-            favorite_models: Vec::new(),
-            default_config_options: Default::default(),
-            favorite_config_option_values: Default::default(),
-        }
-    } else {
-        settings::CustomAgentServerSettings::Extension {
-            default_model: None,
-            default_mode: None,
-            env: Default::default(),
-            favorite_models: Vec::new(),
-            default_config_options: Default::default(),
-            favorite_config_option_values: Default::default(),
-        }
+fn default_settings_for_agent() -> settings::CustomAgentServerSettings {
+    settings::CustomAgentServerSettings::Registry {
+        default_model: None,
+        default_mode: None,
+        env: Default::default(),
+        favorite_models: Vec::new(),
+        default_config_options: Default::default(),
+        favorite_config_option_values: Default::default(),
     }
 }
 
@@ -547,53 +516,4 @@ mod tests {
             assert!(is_registry_agent("agent-from-settings", cx));
         });
     }
-
-    #[gpui::test]
-    fn test_agent_with_extension_settings_type_is_not_registry(cx: &mut TestAppContext) {
-        init_test(cx);
-        set_agent_server_settings(
-            cx,
-            vec![(
-                "my-extension-agent",
-                settings::CustomAgentServerSettings::Extension {
-                    env: HashMap::default(),
-                    default_mode: None,
-                    default_model: None,
-                    favorite_models: Vec::new(),
-                    default_config_options: HashMap::default(),
-                    favorite_config_option_values: HashMap::default(),
-                },
-            )],
-        );
-        cx.update(|cx| {
-            assert!(!is_registry_agent("my-extension-agent", cx));
-        });
-    }
-
-    #[gpui::test]
-    fn test_default_settings_for_extension_agent(cx: &mut TestAppContext) {
-        init_test(cx);
-        cx.update(|cx| {
-            assert!(matches!(
-                default_settings_for_agent("some-extension-agent", cx),
-                settings::CustomAgentServerSettings::Extension { .. }
-            ));
-        });
-    }
-
-    #[gpui::test]
-    fn test_default_settings_for_agent_in_registry(cx: &mut TestAppContext) {
-        init_test(cx);
-        init_registry_with_agents(cx, &["new-registry-agent"]);
-        cx.update(|cx| {
-            assert!(matches!(
-                default_settings_for_agent("new-registry-agent", cx),
-                settings::CustomAgentServerSettings::Registry { .. }
-            ));
-            assert!(matches!(
-                default_settings_for_agent("not-in-registry", cx),
-                settings::CustomAgentServerSettings::Extension { .. }
-            ));
-        });
-    }
 }
diff --git a/crates/agent_ui/src/agent_configuration.rs b/crates/agent_ui/src/agent_configuration.rs
index eb6ea3e81fc..b90a02c30e5 100644
--- a/crates/agent_ui/src/agent_configuration.rs
+++ b/crates/agent_ui/src/agent_configuration.rs
@@ -1174,7 +1174,6 @@ impl AgentConfiguration {
         };
 
         let source_kind = match source {
-            ExternalAgentSource::Extension => AiSettingItemSource::Extension,
             ExternalAgentSource::Registry => AiSettingItemSource::Registry,
             ExternalAgentSource::Custom => AiSettingItemSource::Custom,
         };
@@ -1218,26 +1217,6 @@ impl AgentConfiguration {
         });
 
         let uninstall_button = match source {
-            ExternalAgentSource::Extension => Some(
-                IconButton::new(
-                    SharedString::from(format!("uninstall-{}", id)),
-                    IconName::Trash,
-                )
-                .icon_color(Color::Muted)
-                .icon_size(IconSize::Small)
-                .tooltip(Tooltip::text("Uninstall Agent Extension"))
-                .on_click(cx.listener(move |this, _, _window, cx| {
-                    let agent_name = agent_server_name.clone();
-
-                    if let Some(ext_id) = this.agent_server_store.update(cx, |store, _cx| {
-                        store.get_extension_id_for_agent(&agent_name)
-                    }) {
-                        ExtensionStore::global(cx)
-                            .update(cx, |store, cx| store.uninstall_extension(ext_id, cx))
-                            .detach_and_log_err(cx);
-                    }
-                })),
-            ),
             ExternalAgentSource::Registry => {
                 let fs = self.fs.clone();
                 Some(
diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs
index cd3f7ae2264..f868ff9360e 100644
--- a/crates/agent_ui/src/agent_panel.rs
+++ b/crates/agent_ui/src/agent_panel.rs
@@ -59,7 +59,6 @@ use client::UserStore;
 use cloud_api_types::Plan;
 use collections::HashMap;
 use editor::{Editor, MultiBuffer};
-use extension::ExtensionEvents;
 use extension_host::ExtensionStore;
 
 use fs::Fs;
@@ -1234,21 +1233,14 @@ impl AgentPanel {
         });
 
         // Subscribe to extension events to sync agent servers when extensions change
-        let extension_subscription = if let Some(extension_events) = ExtensionEvents::try_global(cx)
-        {
-            Some(
-                cx.subscribe(&extension_events, |this, _source, event, cx| match event {
-                    extension::Event::ExtensionInstalled(_)
-                    | extension::Event::ExtensionUninstalled(_)
-                    | extension::Event::ExtensionsInstalledChanged => {
-                        this.sync_agent_servers_from_extensions(cx);
-                    }
-                    _ => {}
-                }),
-            )
-        } else {
-            None
-        };
+        let extension_subscription = ExtensionStore::try_global(cx).map(|store| {
+            cx.subscribe(&store, |this, _source, event, cx| match event {
+                extension_host::Event::ExtensionUninstalled(id) => {
+                    this.migrate_agent_server_from_extensions(id.clone(), cx);
+                }
+                _ => {}
+            })
+        });
 
         let connection_store = cx.new(|cx| AgentConnectionStore::new(project.clone(), cx));
         let _project_subscription =
@@ -1280,7 +1272,7 @@ impl AgentPanel {
         })
         .detach();
 
-        let mut panel = Self {
+        let panel = Self {
             workspace_id,
             base_view,
             last_created_entry_kind: AgentPanelEntryKind::Thread,
@@ -1321,8 +1313,6 @@ impl AgentPanel {
             is_active: false,
         };
 
-        // Initial sync of agent servers from extensions
-        panel.sync_agent_servers_from_extensions(cx);
         panel.ensure_native_agent_connection(cx);
         panel
     }
@@ -3901,29 +3891,12 @@ impl AgentPanel {
         })
     }
 
-    fn sync_agent_servers_from_extensions(&mut self, cx: &mut Context<Self>) {
-        if let Some(extension_store) = ExtensionStore::try_global(cx) {
-            let (manifests, extensions_dir) = {
-                let store = extension_store.read(cx);
-                let installed = store.installed_extensions();
-                let manifests: Vec<_> = installed
-                    .iter()
-                    .map(|(id, entry)| (id.clone(), entry.manifest.clone()))
-                    .collect();
-                let extensions_dir = paths::extensions_dir().join("installed");
-                (manifests, extensions_dir)
-            };
-
-            self.project.update(cx, |project, cx| {
-                project.agent_server_store().update(cx, |store, cx| {
-                    let manifest_refs: Vec<_> = manifests
-                        .iter()
-                        .map(|(id, manifest)| (id.as_ref(), manifest.as_ref()))
-                        .collect();
-                    store.sync_extension_agents(manifest_refs, extensions_dir, cx);
-                });
+    fn migrate_agent_server_from_extensions(&mut self, id: Arc<str>, cx: &mut Context<Self>) {
+        self.project.update(cx, |project, cx| {
+            project.agent_server_store().update(cx, |store, cx| {
+                store.migrate_agent_server_from_extensions(id, project.fs().clone(), cx);
             });
-        }
+        });
     }
 
     pub fn new_agent_thread_with_external_source_prompt(
diff --git a/crates/agent_ui/src/agent_registry_ui.rs b/crates/agent_ui/src/agent_registry_ui.rs
index be842e0338d..c6918d869b7 100644
--- a/crates/agent_ui/src/agent_registry_ui.rs
+++ b/crates/agent_ui/src/agent_registry_ui.rs
@@ -34,7 +34,6 @@ enum RegistryInstallStatus {
     NotInstalled,
     InstalledRegistry,
     InstalledCustom,
-    InstalledExtension,
 }
 
 #[derive(IntoElement)]
@@ -155,9 +154,6 @@ impl AgentRegistryPage {
                     RegistryInstallStatus::InstalledRegistry
                 }
                 CustomAgentServerSettings::Custom { .. } => RegistryInstallStatus::InstalledCustom,
-                CustomAgentServerSettings::Extension { .. } => {
-                    RegistryInstallStatus::InstalledExtension
-                }
             };
             self.installed_statuses.insert(id.clone(), status);
         }
@@ -560,9 +556,6 @@ impl AgentRegistryPage {
             RegistryInstallStatus::InstalledCustom => Button::new(button_id, "Installed")
                 .style(ButtonStyle::OutlinedGhost)
                 .disabled(true),
-            RegistryInstallStatus::InstalledExtension => Button::new(button_id, "Installed")
-                .style(ButtonStyle::OutlinedGhost)
-                .disabled(true),
         }
     }
 }
diff --git a/crates/cloud_api_types/src/extension.rs b/crates/cloud_api_types/src/extension.rs
index 1b00312bad0..bb928ddab0d 100644
--- a/crates/cloud_api_types/src/extension.rs
+++ b/crates/cloud_api_types/src/extension.rs
@@ -42,8 +42,11 @@ pub enum ExtensionProvides {
     Grammars,
     LanguageServers,
     ContextServers,
+    /// Deprecated
     AgentServers,
+    /// Deprecated
     SlashCommands,
+    /// Deprecated
     IndexedDocsProviders,
     Snippets,
     DebugAdapters,
diff --git a/crates/extension/src/extension_manifest.rs b/crates/extension/src/extension_manifest.rs
index 919051867d5..c4f7ecd07e7 100644
--- a/crates/extension/src/extension_manifest.rs
+++ b/crates/extension/src/extension_manifest.rs
@@ -107,8 +107,6 @@ pub struct ExtensionManifest {
     #[serde(default)]
     pub context_servers: BTreeMap<Arc<str>, ContextServerManifestEntry>,
     #[serde(default)]
-    pub agent_servers: BTreeMap<Arc<str>, AgentServerManifestEntry>,
-    #[serde(default)]
     pub slash_commands: BTreeMap<Arc<str>, SlashCommandManifestEntry>,
     #[serde(default)]
     pub snippets: Option<ExtensionSnippets>,
@@ -150,10 +148,6 @@ impl ExtensionManifest {
             provides.insert(ExtensionProvides::ContextServers);
         }
 
-        if !self.agent_servers.is_empty() {
-            provides.insert(ExtensionProvides::AgentServers);
-        }
-
         if self.snippets.is_some() {
             provides.insert(ExtensionProvides::Snippets);
         }
@@ -433,7 +427,6 @@ fn manifest_from_old_manifest(
             .collect(),
         language_servers: Default::default(),
         context_servers: BTreeMap::default(),
-        agent_servers: BTreeMap::default(),
         slash_commands: BTreeMap::default(),
         snippets: None,
         capabilities: Vec::new(),
@@ -445,7 +438,6 @@ fn manifest_from_old_manifest(
 
 #[cfg(test)]
 mod tests {
-    use indoc::indoc;
     use pretty_assertions::assert_eq;
     use util::rel_path::rel_path_buf;
 
@@ -469,7 +461,6 @@ mod tests {
             grammars: BTreeMap::default(),
             language_servers: BTreeMap::default(),
             context_servers: BTreeMap::default(),
-            agent_servers: BTreeMap::default(),
             slash_commands: BTreeMap::default(),
             snippets: None,
             capabilities: vec![],
@@ -578,6 +569,8 @@ mod tests {
     #[test]
     #[cfg(target_os = "windows")]
     fn test_deserialize_manifest_with_windows_separators() {
+        use indoc::indoc;
+
         let content = indoc! {r#"
             id = "test-manifest"
             name = "Test Manifest"
@@ -588,32 +581,4 @@ mod tests {
         let manifest: ExtensionManifest = toml::from_str(&content).expect("manifest should parse");
         assert_eq!(manifest.languages, vec![rel_path_buf("foo/bar")]);
     }
-
-    #[test]
-    fn parse_manifest_with_agent_server_archive_launcher() {
-        let toml_src = indoc! {r#"
-            id = "example.agent-server-ext"
-            name = "Agent Server Example"
-            version = "1.0.0"
-            schema_version = 0
-
-            [agent_servers.foo]
-            name = "Foo Agent"
-
-            [agent_servers.foo.targets.linux-x86_64]
-            archive = "https://example.com/agent-linux-x64.tar.gz"
-            cmd = "./agent"
-            args = ["--serve"]
-        "#};
-
-        let manifest: ExtensionManifest = toml::from_str(toml_src).expect("manifest should parse");
-        assert_eq!(manifest.id.as_ref(), "example.agent-server-ext");
-        assert!(manifest.agent_servers.contains_key("foo"));
-        let entry = manifest.agent_servers.get("foo").unwrap();
-        assert!(entry.targets.contains_key("linux-x86_64"));
-        let target = entry.targets.get("linux-x86_64").unwrap();
-        assert_eq!(target.archive, "https://example.com/agent-linux-x64.tar.gz");
-        assert_eq!(target.cmd, "./agent");
-        assert_eq!(target.args, vec!["--serve"]);
-    }
 }
diff --git a/crates/extension_cli/src/main.rs b/crates/extension_cli/src/main.rs
index 737b497fef0..0b7c491ec11 100644
--- a/crates/extension_cli/src/main.rs
+++ b/crates/extension_cli/src/main.rs
@@ -207,21 +207,6 @@ async fn copy_extension_resources(
         .context("failed to copy icons")?;
     }
 
-    for (_, agent_entry) in &manifest.agent_servers {
-        if let Some(icon_path) = &agent_entry.icon {
-            let source_icon = extension_path.join(icon_path);
-            let dest_icon = output_dir.join(icon_path);
-
-            // Create parent directory if needed
-            if let Some(parent) = dest_icon.parent() {
-                fs::create_dir_all(parent)?;
-            }
-
-            fs::copy(&source_icon, &dest_icon)
-                .with_context(|| format!("failed to copy agent server icon '{}'", icon_path))?;
-        }
-    }
-
     if !manifest.languages.is_empty() {
         let output_languages_dir = output_dir.join("languages");
         fs::create_dir_all(&output_languages_dir)?;
diff --git a/crates/extension_host/benches/extension_compilation_benchmark.rs b/crates/extension_host/benches/extension_compilation_benchmark.rs
index 2d3448afe75..b6dade97183 100644
--- a/crates/extension_host/benches/extension_compilation_benchmark.rs
+++ b/crates/extension_host/benches/extension_compilation_benchmark.rs
@@ -137,7 +137,6 @@ fn manifest() -> ExtensionManifest {
             .into_iter()
             .collect(),
         context_servers: BTreeMap::default(),
-        agent_servers: BTreeMap::default(),
         slash_commands: BTreeMap::default(),
         snippets: None,
         capabilities: vec![ExtensionCapability::ProcessExec(
diff --git a/crates/extension_host/src/capability_granter.rs b/crates/extension_host/src/capability_granter.rs
index 6278deef0a7..2cc08d1242c 100644
--- a/crates/extension_host/src/capability_granter.rs
+++ b/crates/extension_host/src/capability_granter.rs
@@ -107,7 +107,6 @@ mod tests {
             grammars: BTreeMap::default(),
             language_servers: BTreeMap::default(),
             context_servers: BTreeMap::default(),
-            agent_servers: BTreeMap::default(),
             slash_commands: BTreeMap::default(),
             snippets: None,
             capabilities: vec![],
diff --git a/crates/extension_host/src/extension_host.rs b/crates/extension_host/src/extension_host.rs
index 3de8e99c5e1..b22d175da56 100644
--- a/crates/extension_host/src/extension_host.rs
+++ b/crates/extension_host/src/extension_host.rs
@@ -11,7 +11,7 @@ use async_compression::futures::bufread::GzipDecoder;
 use async_tar::Archive;
 use client::{Client, proto, telemetry::Telemetry};
 use cloud_api_types::{ExtensionMetadata, ExtensionProvides, GetExtensionsResponse};
-use collections::{BTreeMap, BTreeSet, HashSet, btree_map};
+use collections::{BTreeMap, BTreeSet, FxHashSet, HashSet, btree_map};
 pub use extension::ExtensionManifest;
 use extension::extension_builder::{CompileExtensionOptions, ExtensionBuilder};
 use extension::{
@@ -48,6 +48,7 @@ use serde::{Deserialize, Serialize};
 use settings::{SemanticTokenRules, Settings, SettingsStore};
 use std::ops::RangeInclusive;
 use std::str::FromStr;
+use std::sync::LazyLock;
 use std::{
     cmp::Ordering,
     path::{self, Path, PathBuf},
@@ -77,7 +78,25 @@ const CURRENT_SCHEMA_VERSION: SchemaVersion = SchemaVersion(1);
 ///
 /// These snippets should no longer be downloaded or loaded, because their
 /// functionality has been integrated into the core editor.
-const SUPPRESSED_EXTENSIONS: &[&str] = &["snippets", "ruff", "ty", "basedpyright", "basher"];
+static SUPPRESSED_EXTENSIONS: LazyLock<FxHashSet<&str>> = LazyLock::new(|| {
+    FxHashSet::from_iter([
+        "snippets",
+        "ruff",
+        "ty",
+        "basedpyright",
+        "basher",
+        // ACP
+        "opencode",
+        "mistral-vibe",
+        "auggie",
+        "stakpak",
+        "codebuddy",
+        "autohand-acp",
+        "corust-agent",
+        "factory-droid",
+        "qqcode",
+    ])
+});
 
 /// Returns the [`SchemaVersion`] range that is compatible with this version of Zed.
 pub fn schema_version_range() -> RangeInclusive<SchemaVersion> {
@@ -604,7 +623,7 @@ impl ExtensionStore {
                     .extension_index
                     .extensions
                     .contains_key(extension_id.as_ref());
-                !is_already_installed && !SUPPRESSED_EXTENSIONS.contains(&extension_id.as_ref())
+                !is_already_installed && !SUPPRESSED_EXTENSIONS.contains(extension_id.as_ref())
             })
             .cloned()
             .collect::<Vec<_>>();
@@ -687,7 +706,7 @@ impl ExtensionStore {
 
             response
                 .data
-                .retain(|extension| !SUPPRESSED_EXTENSIONS.contains(&extension.id.as_ref()));
+                .retain(|extension| !SUPPRESSED_EXTENSIONS.contains(extension.id.as_ref()));
 
             Ok(response.data)
         })
@@ -1112,9 +1131,12 @@ impl ExtensionStore {
     ) -> Task<()> {
         let old_index = &self.extension_index;
 
-        new_index
+        let suppressed_extensions_to_remove = new_index
             .extensions
-            .retain(|extension_id, _| !SUPPRESSED_EXTENSIONS.contains(&extension_id.as_ref()));
+            .extract_if(.., |extension_id, _| {
+                SUPPRESSED_EXTENSIONS.contains(extension_id.as_ref())
+            })
+            .collect::<Vec<_>>();
 
         // Determine which extensions need to be loaded and unloaded, based
         // on the changes to the manifest and the extensions that we know have been
@@ -1155,8 +1177,16 @@ impl ExtensionStore {
             self.modified_extensions.clear();
         }
 
+        let trigger_suppressed_extension_removal =
+            move |this: &mut ExtensionStore, cx: &mut Context<ExtensionStore>| {
+                for (id, _) in suppressed_extensions_to_remove {
+                    this.uninstall_extension(id, cx).detach_and_log_err(cx);
+                }
+            };
+
         if extensions_to_load.is_empty() && extensions_to_unload.is_empty() {
             self.reload_complete_senders.clear();
+            trigger_suppressed_extension_removal(self, cx);
             return Task::ready(());
         }
 
@@ -1496,6 +1526,7 @@ impl ExtensionStore {
                 this.proxy.set_extensions_loaded();
                 this.proxy.reload_current_theme(cx);
                 this.proxy.reload_current_icon_theme(cx);
+                trigger_suppressed_extension_removal(this, cx);
 
                 if let Some(events) = ExtensionEvents::try_global(cx) {
                     events.update(cx, |this, cx| {
@@ -1566,10 +1597,6 @@ impl ExtensionStore {
         let mut extension_manifest = ExtensionManifest::load(fs.clone(), &extension_dir).await?;
         let extension_id = extension_manifest.id.clone();
 
-        if SUPPRESSED_EXTENSIONS.contains(&extension_id.as_ref()) {
-            return Ok(());
-        }
-
         // TODO: distinguish dev extensions more explicitly, by the absence
         // of a checksum file that we'll create when downloading normal extensions.
         let is_dev = fs
diff --git a/crates/extension_host/src/extension_store_test.rs b/crates/extension_host/src/extension_store_test.rs
index 2e2408ea2d9..dc554d965ad 100644
--- a/crates/extension_host/src/extension_store_test.rs
+++ b/crates/extension_host/src/extension_store_test.rs
@@ -162,7 +162,6 @@ async fn test_extension_store(cx: &mut TestAppContext) {
                         .collect(),
                         language_servers: BTreeMap::default(),
                         context_servers: BTreeMap::default(),
-                        agent_servers: BTreeMap::default(),
                         slash_commands: BTreeMap::default(),
                         snippets: None,
                         capabilities: Vec::new(),
@@ -194,7 +193,6 @@ async fn test_extension_store(cx: &mut TestAppContext) {
                         grammars: BTreeMap::default(),
                         language_servers: BTreeMap::default(),
                         context_servers: BTreeMap::default(),
-                        agent_servers: BTreeMap::default(),
                         slash_commands: BTreeMap::default(),
                         snippets: None,
                         capabilities: Vec::new(),
@@ -377,7 +375,6 @@ async fn test_extension_store(cx: &mut TestAppContext) {
                 grammars: BTreeMap::default(),
                 language_servers: BTreeMap::default(),
                 context_servers: BTreeMap::default(),
-                agent_servers: BTreeMap::default(),
                 slash_commands: BTreeMap::default(),
                 snippets: None,
                 capabilities: Vec::new(),
diff --git a/crates/extensions_ui/Cargo.toml b/crates/extensions_ui/Cargo.toml
index 6b6b6838313..b1446f0128d 100644
--- a/crates/extensions_ui/Cargo.toml
+++ b/crates/extensions_ui/Cargo.toml
@@ -13,7 +13,6 @@ path = "src/extensions_ui.rs"
 
 [dependencies]
 anyhow.workspace = true
-client.workspace = true
 cloud_api_types.workspace = true
 collections.workspace = true
 db.workspace = true
diff --git a/crates/extensions_ui/src/extensions_ui.rs b/crates/extensions_ui/src/extensions_ui.rs
index af3b9031e44..04c6876b360 100644
--- a/crates/extensions_ui/src/extensions_ui.rs
+++ b/crates/extensions_ui/src/extensions_ui.rs
@@ -7,7 +7,6 @@ use std::time::Duration;
 use std::{ops::Range, sync::Arc};
 
 use anyhow::Context as _;
-use client::zed_urls;
 use cloud_api_types::{ExtensionMetadata, ExtensionProvides};
 use collections::{BTreeMap, BTreeSet};
 use editor::{Editor, EditorElement, EditorStyle};
@@ -68,7 +67,6 @@ pub fn init(cx: &mut App) {
                         ExtensionCategoryFilter::ContextServers => {
                             ExtensionProvides::ContextServers
                         }
-                        ExtensionCategoryFilter::AgentServers => ExtensionProvides::AgentServers,
                         ExtensionCategoryFilter::Snippets => ExtensionProvides::Snippets,
                         ExtensionCategoryFilter::DebugAdapters => ExtensionProvides::DebugAdapters,
                     });
@@ -287,19 +285,6 @@ fn keywords_by_feature() -> &'static BTreeMap<Feature, Vec<&'static str>> {
     })
 }
 
-fn acp_registry_upsell_keywords() -> &'static [&'static str] {
-    &[
-        "opencode",
-        "mistral",
-        "auggie",
-        "stakpak",
-        "codebuddy",
-        "autohand",
-        "factory droid",
-        "corust",
-    ]
-}
-
 fn extension_button_id(extension_id: &Arc<str>, operation: ExtensionOperation) -> ElementId {
     (SharedString::from(extension_id.clone()), operation as usize).into()
 }
@@ -326,7 +311,6 @@ pub struct ExtensionsPage {
     _subscriptions: [gpui::Subscription; 2],
     extension_fetch_task: Option<Task<()>>,
     upsells: BTreeSet<Feature>,
-    show_acp_registry_upsell: bool,
 }
 
 impl ExtensionsPage {
@@ -389,7 +373,6 @@ impl ExtensionsPage {
                 _subscriptions: subscriptions,
                 query_editor,
                 upsells: BTreeSet::default(),
-                show_acp_registry_upsell: false,
             };
             this.fetch_extensions(
                 this.search_query(cx),
@@ -824,7 +807,8 @@ impl ExtensionsPage {
                                             .iter()
                                             .filter_map(|provides| {
                                                 match provides {
-                                                    ExtensionProvides::SlashCommands
+                                                    ExtensionProvides::AgentServers
+                                                    | ExtensionProvides::SlashCommands
                                                     | ExtensionProvides::IndexedDocsProviders => {
                                                         return None;
                                                     }
@@ -1416,13 +1400,11 @@ impl ExtensionsPage {
     fn refresh_feature_upsells(&mut self, cx: &mut Context<Self>) {
         let Some(search) = self.search_query(cx) else {
             self.upsells.clear();
-            self.show_acp_registry_upsell = false;
             return;
         };
 
         if let Some(id) = search.strip_prefix("id:") {
             self.upsells.clear();
-            self.show_acp_registry_upsell = false;
 
             let upsell = match id.to_lowercase().as_str() {
                 "ruff" => Some(Feature::ExtensionRuff),
@@ -1454,61 +1436,6 @@ impl ExtensionsPage {
                 self.upsells.remove(feature);
             }
         }
-
-        self.show_acp_registry_upsell = acp_registry_upsell_keywords()
-            .iter()
-            .any(|keyword| search_terms.iter().any(|term| keyword.contains(term)));
-    }
-
-    fn render_acp_registry_upsell(&self, cx: &mut Context<Self>) -> impl IntoElement {
-        let registry_url = zed_urls::acp_registry_blog(cx);
-
-        let view_registry = Button::new("view_registry", "View Registry")
-            .style(ButtonStyle::Tinted(ui::TintColor::Warning))
-            .on_click({
-                let registry_url = registry_url.clone();
-                move |_, window, cx| {
-                    telemetry::event!(
-                        "ACP Registry Opened from Extensions",
-                        source = "ACP Registry Upsell",
-                        url = registry_url,
-                    );
-                    window.dispatch_action(Box::new(zed_actions::AcpRegistry), cx)
-                }
-            });
-        let open_registry_button = Button::new("open_registry", "Learn More")
-            .end_icon(
-                Icon::new(IconName::ArrowUpRight)
-                    .size(IconSize::Small)
-                    .color(Color::Muted),
-            )
-            .on_click({
-                move |_event, _window, cx| {
-                    telemetry::event!(
-                        "ACP Registry Viewed",
-                        source = "ACP Registry Upsell",
-                        url = registry_url,
-                    );
-                    cx.open_url(&registry_url)
-                }
-            });
-
-        div().pt_4().px_4().child(
-            Banner::new()
-                .severity(Severity::Warning)
-                .child(
-                    Label::new(
-                        "Agent Server extensions will be deprecated in favor of the ACP registry.",
-                    )
-                    .mt_0p5(),
-                )
-                .action_slot(
-                    h_flex()
-                        .gap_1()
-                        .child(open_registry_button)
-                        .child(view_registry),
-                ),
-        )
     }
 
     fn render_feature_upsell_banner(
@@ -1832,11 +1759,6 @@ impl Render for ExtensionsPage {
                         )
                     })),
             )
-            .when(
-                self.provides_filter == Some(ExtensionProvides::AgentServers)
-                    || self.show_acp_registry_upsell,
-                |this| this.child(self.render_acp_registry_upsell(cx)),
-            )
             .child(self.render_feature_upsells(cx))
             .child(v_flex().px_4().size_full().overflow_y_hidden().map(|this| {
                 let mut count = self.filtered_remote_extension_indices.len();
diff --git a/crates/project/src/agent_server_store.rs b/crates/project/src/agent_server_store.rs
index f43f045c5e0..81779906ed6 100644
--- a/crates/project/src/agent_server_store.rs
+++ b/crates/project/src/agent_server_store.rs
@@ -1,7 +1,7 @@
 use std::{
     any::Any,
     path::{Path, PathBuf},
-    sync::Arc,
+    sync::{Arc, LazyLock},
     time::Duration,
 };
 
@@ -17,14 +17,11 @@ use http_client::{HttpClient, github::AssetKind};
 use node_runtime::NodeRuntime;
 use percent_encoding::percent_decode_str;
 use remote::RemoteClient;
-use rpc::{
-    AnyProtoClient, TypedEnvelope,
-    proto::{self, ExternalExtensionAgent},
-};
+use rpc::{AnyProtoClient, TypedEnvelope, proto};
 use schemars::JsonSchema;
 use semver::Version;
 use serde::{Deserialize, Serialize};
-use settings::{RegisterSetting, SettingsStore};
+use settings::{RegisterSetting, SettingsStore, update_settings_file};
 use sha2::{Digest, Sha256};
 use url::Url;
 use util::{ResultExt as _, debug_panic};
@@ -114,7 +111,6 @@ impl std::borrow::Borrow<str> for AgentId {
 pub enum ExternalAgentSource {
     #[default]
     Custom,
-    Extension,
     Registry,
 }
 
@@ -140,16 +136,6 @@ pub trait ExternalAgentServer {
     fn as_any_mut(&mut self) -> &mut dyn Any;
 }
 
-struct ExtensionAgentEntry {
-    agent_name: Arc<str>,
-    extension_id: String,
-    targets: HashMap<String, extension::TargetConfig>,
-    env: HashMap<String, String>,
-    icon_path: Option<String>,
-    display_name: Option<SharedString>,
-    version: Option<SharedString>,
-}
-
 enum AgentServerStoreState {
     Local {
         node_runtime: NodeRuntime,
@@ -158,7 +144,6 @@ enum AgentServerStoreState {
         downstream_client: Option<(u64, AnyProtoClient)>,
         settings: Option<AllAgentServersSettings>,
         http_client: Arc<dyn HttpClient>,
-        extension_agents: Vec<ExtensionAgentEntry>,
         _subscriptions: Vec<Subscription>,
     },
     Remote {
@@ -201,123 +186,54 @@ pub struct AgentServersUpdated;
 
 impl EventEmitter<AgentServersUpdated> for AgentServerStore {}
 
+static EXTENSION_TO_REGISTRY_IDS: LazyLock<HashMap<&'static str, &'static str>> =
+    LazyLock::new(|| {
+        HashMap::from_iter([
+            ("opencode", "opencode"),
+            ("mistral-vibe", "mistral-vibe"),
+            ("auggie", "auggie"),
+            ("stakpak", "stakpak"),
+            ("codebuddy", "codebuddy-code"),
+            ("autohand-acp", "autohand"),
+            ("corust-agent", "corust-agent"),
+            ("factory-droid", "factory-droid"),
+            // Unmaintained
+            // ("qqcode", ""),
+        ])
+    });
+
 impl AgentServerStore {
-    /// Synchronizes extension-provided agent servers with the store.
-    pub fn sync_extension_agents<'a, I>(
+    pub fn migrate_agent_server_from_extensions(
         &mut self,
-        manifests: I,
-        extensions_dir: PathBuf,
+        id: Arc<str>,
+        fs: Arc<dyn Fs>,
         cx: &mut Context<Self>,
-    ) where
-        I: IntoIterator<Item = (&'a str, &'a extension::ExtensionManifest)>,
-    {
-        // Collect manifests first so we can iterate twice
-        let manifests: Vec<_> = manifests.into_iter().collect();
+    ) {
+        let Some(registry_id) = EXTENSION_TO_REGISTRY_IDS.get(id.as_ref()) else {
+            return;
+        };
 
-        // Remove all extension-provided agents
-        // (They will be re-added below if they're in the currently installed extensions)
-        self.external_agents
-            .retain(|_, entry| entry.source != ExternalAgentSource::Extension);
-
-        // Insert agent servers from extension manifests
-        match &mut self.state {
-            AgentServerStoreState::Local {
-                extension_agents, ..
-            } => {
-                extension_agents.clear();
-                for (ext_id, manifest) in manifests {
-                    for (agent_name, agent_entry) in &manifest.agent_servers {
-                        let display_name = SharedString::from(agent_entry.name.clone());
-                        let icon_path = agent_entry.icon.as_ref().and_then(|icon| {
-                            resolve_extension_icon_path(&extensions_dir, ext_id, icon)
-                        });
-
-                        extension_agents.push(ExtensionAgentEntry {
-                            agent_name: agent_name.clone(),
-                            extension_id: ext_id.to_owned(),
-                            targets: agent_entry.targets.clone(),
-                            env: agent_entry.env.clone(),
-                            icon_path,
-                            display_name: Some(display_name),
-                            version: Some(SharedString::from(manifest.version.clone())),
-                        });
-                    }
-                }
-                self.reregister_agents(cx);
+        update_settings_file(fs, cx, move |settings, _| {
+            let agent_servers = settings.agent_servers.get_or_insert_default();
+            // Take the old settings
+            let settings = agent_servers.remove(id.as_ref());
+            // If they had both installed, just remove the extension settings, leave theirregistry settings alone
+            if agent_servers.contains_key(*registry_id) {
+                return;
             }
-            AgentServerStoreState::Remote {
-                project_id,
-                upstream_client,
-                worktree_store,
-            } => {
-                let mut agents = vec![];
-                for (ext_id, manifest) in manifests {
-                    for (agent_name, agent_entry) in &manifest.agent_servers {
-                        let display_name = SharedString::from(agent_entry.name.clone());
-                        let icon_path = agent_entry.icon.as_ref().and_then(|icon| {
-                            resolve_extension_icon_path(&extensions_dir, ext_id, icon)
-                        });
-                        let icon_shared = icon_path
-                            .as_ref()
-                            .map(|path| SharedString::from(path.clone()));
-                        let icon = icon_path;
-                        let agent_server_name = AgentId(agent_name.clone().into());
-                        self.external_agents
-                            .entry(agent_server_name.clone())
-                            .and_modify(|entry| {
-                                entry.icon = icon_shared.clone();
-                                entry.display_name = Some(display_name.clone());
-                                entry.source = ExternalAgentSource::Extension;
-                            })
-                            .or_insert_with(|| {
-                                ExternalAgentEntry::new(
-                                    Box::new(RemoteExternalAgentServer {
-                                        project_id: *project_id,
-                                        upstream_client: upstream_client.clone(),
-                                        worktree_store: worktree_store.clone(),
-                                        name: agent_server_name.clone(),
-                                        new_version_available_tx: None,
-                                    })
-                                        as Box<dyn ExternalAgentServer>,
-                                    ExternalAgentSource::Extension,
-                                    icon_shared.clone(),
-                                    Some(display_name.clone()),
-                                )
-                            });
-
-                        agents.push(ExternalExtensionAgent {
-                            name: agent_name.to_string(),
-                            icon_path: icon,
-                            extension_id: ext_id.to_string(),
-                            targets: agent_entry
-                                .targets
-                                .iter()
-                                .map(|(k, v)| (k.clone(), v.to_proto()))
-                                .collect(),
-                            env: agent_entry
-                                .env
-                                .iter()
-                                .map(|(k, v)| (k.clone(), v.clone()))
-                                .collect(),
-                            version: Some(manifest.version.to_string()),
-                        });
-                    }
-                }
-                upstream_client
-                    .read(cx)
-                    .proto_client()
-                    .send(proto::ExternalExtensionAgentsUpdated {
-                        project_id: *project_id,
-                        agents,
-                    })
-                    .log_err();
-            }
-            AgentServerStoreState::Collab => {
-                // Do nothing
-            }
-        }
-
-        cx.emit(AgentServersUpdated);
+            // Insert the old settings, or write new ones so it is "installed" via the registry
+            agent_servers.insert(
+                registry_id.to_string(),
+                settings.unwrap_or_else(|| settings::CustomAgentServerSettings::Registry {
+                    default_mode: None,
+                    default_model: None,
+                    env: Default::default(),
+                    favorite_models: Vec::new(),
+                    default_config_options: HashMap::default(),
+                    favorite_config_option_values: HashMap::default(),
+                }),
+            );
+        });
     }
 
     pub fn agent_icon(&self, id: &AgentId) -> Option<SharedString> {
@@ -331,46 +247,6 @@ impl AgentServerStore {
     }
 }
 
-/// Safely resolves an extension icon path, ensuring it stays within the extension directory.
-/// Returns `None` if the path would escape the extension directory (path traversal attack).
-pub fn resolve_extension_icon_path(
-    extensions_dir: &Path,
-    extension_id: &str,
-    icon_relative_path: &str,
-) -> Option<String> {
-    let extension_root = extensions_dir.join(extension_id);
-    let icon_path = extension_root.join(icon_relative_path);
-
-    // Canonicalize both paths to resolve symlinks and normalize the paths.
-    // For the extension root, we need to handle the case where it might be a symlink
-    // (common for dev extensions).
-    let canonical_extension_root = extension_root.canonicalize().unwrap_or(extension_root);
-    let canonical_icon_path = match icon_path.canonicalize() {
-        Ok(path) => path,
-        Err(err) => {
-            log::warn!(
-                "Failed to canonicalize icon path for extension '{}': {} (path: {})",
-                extension_id,
-                err,
-                icon_relative_path
-            );
-            return None;
-        }
-    };
-
-    // Verify the resolved icon path is within the extension directory
-    if canonical_icon_path.starts_with(&canonical_extension_root) {
-        Some(canonical_icon_path.to_string_lossy().to_string())
-    } else {
-        log::warn!(
-            "Icon path '{}' for extension '{}' escapes extension directory, ignoring for security",
-            icon_relative_path,
-            extension_id
-        );
-        None
-    }
-}
-
 impl AgentServerStore {
     pub fn agent_display_name(&self, name: &AgentId) -> Option<SharedString> {
         self.external_agents
@@ -384,7 +260,6 @@ impl AgentServerStore {
     }
 
     pub fn init_headless(session: &AnyProtoClient) {
-        session.add_entity_message_handler(Self::handle_external_extension_agents_updated);
         session.add_entity_request_handler(Self::handle_get_agent_server_command);
     }
 
@@ -419,7 +294,6 @@ impl AgentServerStore {
             downstream_client,
             settings: old_settings,
             http_client,
-            extension_agents,
             ..
         } = &mut self.state
         else {
@@ -470,47 +344,6 @@ impl AgentServerStore {
             }
         }
 
-        // Insert extension agents before custom/registry so registry entries override extensions.
-        for entry in extension_agents.iter() {
-            let name = AgentId(entry.agent_name.clone().into());
-            let mut env = entry.env.clone();
-            if let Some(settings_env) =
-                new_settings
-                    .get(entry.agent_name.as_ref())
-                    .and_then(|settings| match settings {
-                        CustomAgentServerSettings::Extension { env, .. } => Some(env.clone()),
-                        _ => None,
-                    })
-            {
-                env.extend(settings_env);
-            }
-            let icon = entry
-                .icon_path
-                .as_ref()
-                .map(|path| SharedString::from(path.clone()));
-
-            self.external_agents.insert(
-                name.clone(),
-                ExternalAgentEntry::new(
-                    Box::new(LocalExtensionArchiveAgent {
-                        fs: fs.clone(),
-                        http_client: http_client.clone(),
-                        node_runtime: node_runtime.clone(),
-                        project_environment: project_environment.clone(),
-                        extension_id: Arc::from(&*entry.extension_id),
-                        targets: entry.targets.clone(),
-                        env,
-                        agent_id: entry.agent_name.clone(),
-                        version: entry.version.clone(),
-                        new_version_available_tx: None,
-                    }) as Box<dyn ExternalAgentServer>,
-                    ExternalAgentSource::Extension,
-                    icon,
-                    entry.display_name.clone(),
-                ),
-            );
-        }
-
         for (name, settings) in new_settings.iter() {
             match settings {
                 CustomAgentServerSettings::Custom { command, .. } => {
@@ -593,7 +426,6 @@ impl AgentServerStore {
                         }
                     }
                 }
-                CustomAgentServerSettings::Extension { .. } => {}
             }
         }
 
@@ -662,12 +494,10 @@ impl AgentServerStore {
                 http_client,
                 downstream_client: None,
                 settings: None,
-                extension_agents: vec![],
                 _subscriptions: subscriptions,
             },
             external_agents: HashMap::default(),
         };
-        if let Some(_events) = extension::ExtensionEvents::try_global(cx) {}
         this.agent_servers_settings_changed(cx);
         this
     }
@@ -900,52 +730,6 @@ impl AgentServerStore {
         })
     }
 
-    async fn handle_external_extension_agents_updated(
-        this: Entity<Self>,
-        envelope: TypedEnvelope<proto::ExternalExtensionAgentsUpdated>,
-        mut cx: AsyncApp,
-    ) -> Result<()> {
-        this.update(&mut cx, |this, cx| {
-            let AgentServerStoreState::Local {
-                extension_agents, ..
-            } = &mut this.state
-            else {
-                panic!(
-                    "handle_external_extension_agents_updated \
-                    should not be called for a non-remote project"
-                );
-            };
-
-            extension_agents.clear();
-            for ExternalExtensionAgent {
-                name,
-                icon_path,
-                extension_id,
-                targets,
-                env,
-                version,
-            } in envelope.payload.agents
-            {
-                extension_agents.push(ExtensionAgentEntry {
-                    agent_name: Arc::from(&*name),
-                    extension_id,
-                    targets: targets
-                        .into_iter()
-                        .map(|(k, v)| (k, extension::TargetConfig::from_proto(v)))
-                        .collect(),
-                    env: env.into_iter().collect(),
-                    icon_path,
-                    display_name: None,
-                    version: version.map(SharedString::from),
-                });
-            }
-
-            this.reregister_agents(cx);
-            cx.emit(AgentServersUpdated);
-            Ok(())
-        })
-    }
-
     async fn handle_new_version_available(
         this: Entity<Self>,
         envelope: TypedEnvelope<proto::NewExternalAgentVersionAvailable>,
@@ -961,16 +745,6 @@ impl AgentServerStore {
         });
         Ok(())
     }
-
-    pub fn get_extension_id_for_agent(&self, name: &AgentId) -> Option<Arc<str>> {
-        self.external_agents.get(name).and_then(|entry| {
-            entry
-                .server
-                .as_any()
-                .downcast_ref::<LocalExtensionArchiveAgent>()
-                .map(|ext_agent| ext_agent.extension_id.clone())
-        })
-    }
 }
 
 struct RemoteExternalAgentServer {
@@ -1196,213 +970,6 @@ async fn remove_stale_versioned_archive_cache_dirs(
     Ok(())
 }
 
-pub struct LocalExtensionArchiveAgent {
-    pub fs: Arc<dyn Fs>,
-    pub http_client: Arc<dyn HttpClient>,
-    pub node_runtime: NodeRuntime,
-    pub project_environment: Entity<ProjectEnvironment>,
-    pub extension_id: Arc<str>,
-    pub agent_id: Arc<str>,
-    pub targets: HashMap<String, extension::TargetConfig>,
-    pub env: HashMap<String, String>,
-    pub version: Option<SharedString>,
-    pub new_version_available_tx: Option<watch::Sender<Option<String>>>,
-}
-
-impl ExternalAgentServer for LocalExtensionArchiveAgent {
-    fn version(&self) -> Option<&SharedString> {
-        self.version.as_ref()
-    }
-
-    fn take_new_version_available_tx(&mut self) -> Option<watch::Sender<Option<String>>> {
-        self.new_version_available_tx.take()
-    }
-
-    fn set_new_version_available_tx(&mut self, tx: watch::Sender<Option<String>>) {
-        self.new_version_available_tx = Some(tx);
-    }
-
-    fn get_command(
-        &self,
-        extra_args: Vec<String>,
-        extra_env: HashMap<String, String>,
-        cx: &mut AsyncApp,
-    ) -> Task<Result<AgentServerCommand>> {
-        let fs = self.fs.clone();
-        let http_client = self.http_client.clone();
-        let node_runtime = self.node_runtime.clone();
-        let project_environment = self.project_environment.downgrade();
-        let extension_id = self.extension_id.clone();
-        let agent_id = self.agent_id.clone();
-        let targets = self.targets.clone();
-        let base_env = self.env.clone();
-        let version = self.version.clone();
-
-        cx.spawn(async move |cx| {
-            // Get project environment
-            let mut env = project_environment
-                .update(cx, |project_environment, cx| {
-                    project_environment.default_environment(cx)
-                })?
-                .await
-                .unwrap_or_default();
-
-            // Merge manifest env and extra env
-            env.extend(base_env);
-            env.extend(extra_env);
-
-            let cache_key = format!("{}/{}", extension_id, agent_id);
-            let dir = paths::external_agents_dir().join(&cache_key);
-            fs.create_dir(&dir).await?;
-
-            // Determine platform key
-            let os = if cfg!(target_os = "macos") {
-                "darwin"
-            } else if cfg!(target_os = "linux") {
-                "linux"
-            } else if cfg!(target_os = "windows") {
-                "windows"
-            } else {
-                anyhow::bail!("unsupported OS");
-            };
-
-            let arch = if cfg!(target_arch = "aarch64") {
-                "aarch64"
-            } else if cfg!(target_arch = "x86_64") {
-                "x86_64"
-            } else {
-                anyhow::bail!("unsupported architecture");
-            };
-
-            let platform_key = format!("{}-{}", os, arch);
-            let target_config = targets.get(&platform_key).with_context(|| {
-                format!(
-                    "no target specified for platform '{}'. Available platforms: {}",
-                    platform_key,
-                    targets
-                        .keys()
-                        .map(|k| k.as_str())
-                        .collect::<Vec<_>>()
-                        .join(", ")
-                )
-            })?;
-
-            let archive_url = &target_config.archive;
-            let version_dir = versioned_archive_cache_dir(
-                &dir,
-                version.as_ref().map(|version| version.as_ref()),
-                archive_url,
-            );
-
-            if !fs.is_dir(&version_dir).await {
-                // Determine SHA256 for verification
-                let sha256 = if let Some(provided_sha) = &target_config.sha256 {
-                    // Use provided SHA256
-                    Some(provided_sha.clone())
-                } else if let Some(github_archive) = github_release_archive_from_url(archive_url) {
-                    // Try to fetch SHA256 from GitHub API
-                    if let Ok(release) = ::http_client::github::get_release_by_tag_name(
-                        &github_archive.repo_name_with_owner,
-                        &github_archive.tag,
-                        http_client.clone(),
-                    )
-                    .await
-                    {
-                        // Find matching asset
-                        if let Some(asset) = release
-                            .assets
-                            .iter()
-                            .find(|a| a.name == github_archive.asset_name)
-                        {
-                            // Strip "sha256:" prefix if present
-                            asset.digest.as_ref().map(|d| {
-                                d.strip_prefix("sha256:")
-                                    .map(|s| s.to_string())
-                                    .unwrap_or_else(|| d.clone())
-                            })
-                        } else {
-                            None
-                        }
-                    } else {
-                        None
-                    }
-                } else {
-                    None
-                };
-
-                let asset_kind = asset_kind_for_archive_url(archive_url)?;
-
-                // Download and extract
-                ::http_client::github_download::download_server_binary(
-                    &*http_client,
-                    archive_url,
-                    sha256.as_deref(),
-                    &version_dir,
-                    asset_kind,
-                )
-                .await?;
-            }
-
-            // Validate and resolve cmd path
-            let cmd = &target_config.cmd;
-
-            let cmd_path = if cmd == "node" {
-                // Use Zed's managed Node.js runtime
-                node_runtime.binary_path().await?
-            } else {
-                if cmd.contains("..") {
-                    anyhow::bail!("command path cannot contain '..': {}", cmd);
-                }
-
-                if cmd.starts_with("./") || cmd.starts_with(".\\") {
-                    // Relative to extraction directory
-                    let cmd_path = version_dir.join(&cmd[2..]);
-                    anyhow::ensure!(
-                        fs.is_file(&cmd_path).await,
-                        "Missing command {} after extraction",
-                        cmd_path.to_string_lossy()
-                    );
-                    cmd_path
-                } else {
-                    // On PATH
-                    anyhow::bail!("command must be relative (start with './'): {}", cmd);
-                }
-            };
-
-            cx.background_spawn({
-                let fs = fs.clone();
-                let dir = dir.clone();
-                let version_dir = version_dir.clone();
-                async move {
-                    remove_stale_versioned_archive_cache_dirs(fs, &dir, &version_dir)
-                        .await
-                        .log_err();
-                }
-            })
-            .detach();
-
-            let mut args = target_config.args.clone();
-            args.extend(extra_args);
-
-            let command = AgentServerCommand {
-                path: cmd_path,
-                args,
-                env: Some(env),
-            };
-
-            Ok(command)
-        })
-    }
-
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn as_any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-}
-
 struct LocalRegistryArchiveAgent {
     fs: Arc<dyn Fs>,
     http_client: Arc<dyn HttpClient>,
@@ -1813,40 +1380,6 @@ pub enum CustomAgentServerSettings {
         /// Default: {}
         favorite_config_option_values: HashMap<String, Vec<String>>,
     },
-    Extension {
-        /// Additional environment variables to pass to the agent.
-        ///
-        /// Default: {}
-        env: HashMap<String, String>,
-        /// The default mode to use for this agent.
-        ///
-        /// Note: Not only all agents support modes.
-        ///
-        /// Default: None
-        default_mode: Option<String>,
-        /// The default model to use for this agent.
-        ///
-        /// This should be the model ID as reported by the agent.
-        ///
-        /// Default: None
-        default_model: Option<String>,
-        /// The favorite models for this agent.
-        ///
-        /// Default: []
-        favorite_models: Vec<String>,
-        /// Default values for session config options.
-        ///
-        /// This is a map from config option ID to value ID.
-        ///
-        /// Default: {}
-        default_config_options: HashMap<String, String>,
-        /// Favorited values for session config options.
-        ///
-        /// This is a map from config option ID to a list of favorited value IDs.
-        ///
-        /// Default: {}
-        favorite_config_option_values: HashMap<String, Vec<String>>,
-    },
     Registry {
         /// Additional environment variables to pass to the agent.
         ///
@@ -1887,15 +1420,13 @@ impl CustomAgentServerSettings {
     pub fn command(&self) -> Option<&AgentServerCommand> {
         match self {
             CustomAgentServerSettings::Custom { command, .. } => Some(command),
-            CustomAgentServerSettings::Extension { .. }
-            | CustomAgentServerSettings::Registry { .. } => None,
+            CustomAgentServerSettings::Registry { .. } => None,
         }
     }
 
     pub fn default_mode(&self) -> Option<&str> {
         match self {
             CustomAgentServerSettings::Custom { default_mode, .. }
-            | CustomAgentServerSettings::Extension { default_mode, .. }
             | CustomAgentServerSettings::Registry { default_mode, .. } => default_mode.as_deref(),
         }
     }
@@ -1903,7 +1434,6 @@ impl CustomAgentServerSettings {
     pub fn default_model(&self) -> Option<&str> {
         match self {
             CustomAgentServerSettings::Custom { default_model, .. }
-            | CustomAgentServerSettings::Extension { default_model, .. }
             | CustomAgentServerSettings::Registry { default_model, .. } => default_model.as_deref(),
         }
     }
@@ -1913,9 +1443,6 @@ impl CustomAgentServerSettings {
             CustomAgentServerSettings::Custom {
                 favorite_models, ..
             }
-            | CustomAgentServerSettings::Extension {
-                favorite_models, ..
-            }
             | CustomAgentServerSettings::Registry {
                 favorite_models, ..
             } => favorite_models,
@@ -1928,10 +1455,6 @@ impl CustomAgentServerSettings {
                 default_config_options,
                 ..
             }
-            | CustomAgentServerSettings::Extension {
-                default_config_options,
-                ..
-            }
             | CustomAgentServerSettings::Registry {
                 default_config_options,
                 ..
@@ -1945,10 +1468,6 @@ impl CustomAgentServerSettings {
                 favorite_config_option_values,
                 ..
             }
-            | CustomAgentServerSettings::Extension {
-                favorite_config_option_values,
-                ..
-            }
             | CustomAgentServerSettings::Registry {
                 favorite_config_option_values,
                 ..
@@ -1983,21 +1502,6 @@ impl From<settings::CustomAgentServerSettings> for CustomAgentServerSettings {
                 default_config_options,
                 favorite_config_option_values,
             },
-            settings::CustomAgentServerSettings::Extension {
-                env,
-                default_mode,
-                default_model,
-                default_config_options,
-                favorite_models,
-                favorite_config_option_values,
-            } => CustomAgentServerSettings::Extension {
-                env,
-                default_mode,
-                default_model,
-                default_config_options,
-                favorite_models,
-                favorite_config_option_values,
-            },
             settings::CustomAgentServerSettings::Registry {
                 env,
                 default_mode,
@@ -2024,7 +1528,15 @@ impl settings::Settings for AllAgentServersSettings {
             agent_settings
                 .0
                 .into_iter()
-                .map(|(k, v)| (k, v.into()))
+                .map(|(k, v)| {
+                    (
+                        EXTENSION_TO_REGISTRY_IDS
+                            .get(&k.as_str())
+                            .map(|v| v.to_string())
+                            .unwrap_or(k),
+                        v.into(),
+                    )
+                })
                 .collect(),
         )
     }
diff --git a/crates/project/tests/integration/ext_agent_tests.rs b/crates/project/tests/integration/ext_agent_tests.rs
deleted file mode 100644
index 82135485d3f..00000000000
--- a/crates/project/tests/integration/ext_agent_tests.rs
+++ /dev/null
@@ -1,224 +0,0 @@
-use anyhow::Result;
-use collections::HashMap;
-use gpui::{AsyncApp, SharedString, Task};
-use project::agent_server_store::*;
-use std::{any::Any, collections::HashSet, fmt::Write as _, path::PathBuf};
-// A simple fake that implements ExternalAgentServer without needing async plumbing.
-struct NoopExternalAgent;
-
-impl ExternalAgentServer for NoopExternalAgent {
-    fn get_command(
-        &self,
-        _extra_args: Vec<String>,
-        _extra_env: HashMap<String, String>,
-        _cx: &mut AsyncApp,
-    ) -> Task<Result<AgentServerCommand>> {
-        Task::ready(Ok(AgentServerCommand {
-            path: PathBuf::from("noop"),
-            args: Vec::new(),
-            env: None,
-        }))
-    }
-
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn as_any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-}
-
-#[test]
-fn external_agent_server_name_display() {
-    let name = AgentId(SharedString::from("Ext: Tool"));
-    let mut s = String::new();
-    write!(&mut s, "{name}").unwrap();
-    assert_eq!(s, "Ext: Tool");
-}
-
-#[test]
-fn sync_extension_agents_removes_previous_extension_entries() {
-    let mut store = AgentServerStore::collab();
-
-    // Seed with a couple of agents that will be replaced by extensions
-    store.external_agents.insert(
-        AgentId(SharedString::from("foo-agent")),
-        ExternalAgentEntry::new(
-            Box::new(NoopExternalAgent) as Box<dyn ExternalAgentServer>,
-            ExternalAgentSource::Custom,
-            None,
-            None,
-        ),
-    );
-    store.external_agents.insert(
-        AgentId(SharedString::from("bar-agent")),
-        ExternalAgentEntry::new(
-            Box::new(NoopExternalAgent) as Box<dyn ExternalAgentServer>,
-            ExternalAgentSource::Custom,
-            None,
-            None,
-        ),
-    );
-    store.external_agents.insert(
-        AgentId(SharedString::from("custom")),
-        ExternalAgentEntry::new(
-            Box::new(NoopExternalAgent) as Box<dyn ExternalAgentServer>,
-            ExternalAgentSource::Custom,
-            None,
-            None,
-        ),
-    );
-
-    // Simulate the removal phase: if we're syncing extensions that provide
-    // "foo-agent" and "bar-agent", those should be removed first
-    let extension_agent_names: HashSet<String> = ["foo-agent".to_string(), "bar-agent".to_string()]
-        .into_iter()
-        .collect();
-
-    let keys_to_remove: Vec<_> = store
-        .external_agents
-        .keys()
-        .filter(|name| extension_agent_names.contains(name.0.as_ref()))
-        .cloned()
-        .collect();
-
-    for key in keys_to_remove {
-        store.external_agents.remove(&key);
-    }
-
-    // Only the custom entry should remain.
-    let remaining: Vec<_> = store
-        .external_agents
-        .keys()
-        .map(|k| k.0.to_string())
-        .collect();
-    assert_eq!(remaining, vec!["custom".to_string()]);
-}
-
-#[test]
-fn resolve_extension_icon_path_allows_valid_paths() {
-    // Create a temporary directory structure for testing
-    let temp_dir = tempfile::tempdir().unwrap();
-    let extensions_dir = temp_dir.path();
-    let ext_dir = extensions_dir.join("my-extension");
-    std::fs::create_dir_all(&ext_dir).unwrap();
-
-    // Create a valid icon file
-    let icon_path = ext_dir.join("icon.svg");
-    std::fs::write(&icon_path, "<svg></svg>").unwrap();
-
-    // Test that a valid relative path works
-    let result = project::agent_server_store::resolve_extension_icon_path(
-        extensions_dir,
-        "my-extension",
-        "icon.svg",
-    );
-    assert!(result.is_some());
-    assert!(result.unwrap().ends_with("icon.svg"));
-}
-
-#[test]
-fn resolve_extension_icon_path_allows_nested_paths() {
-    let temp_dir = tempfile::tempdir().unwrap();
-    let extensions_dir = temp_dir.path();
-    let ext_dir = extensions_dir.join("my-extension");
-    let icons_dir = ext_dir.join("assets").join("icons");
-    std::fs::create_dir_all(&icons_dir).unwrap();
-
-    let icon_path = icons_dir.join("logo.svg");
-    std::fs::write(&icon_path, "<svg></svg>").unwrap();
-
-    let result = project::agent_server_store::resolve_extension_icon_path(
-        extensions_dir,
-        "my-extension",
-        "assets/icons/logo.svg",
-    );
-    assert!(result.is_some());
-    assert!(result.unwrap().ends_with("logo.svg"));
-}
-
-#[test]
-fn resolve_extension_icon_path_blocks_path_traversal() {
-    let temp_dir = tempfile::tempdir().unwrap();
-    let extensions_dir = temp_dir.path();
-
-    // Create two extension directories
-    let ext1_dir = extensions_dir.join("extension1");
-    let ext2_dir = extensions_dir.join("extension2");
-    std::fs::create_dir_all(&ext1_dir).unwrap();
-    std::fs::create_dir_all(&ext2_dir).unwrap();
-
-    // Create a file in extension2
-    let secret_file = ext2_dir.join("secret.svg");
-    std::fs::write(&secret_file, "<svg>secret</svg>").unwrap();
-
-    // Try to access extension2's file from extension1 using path traversal
-    let result = project::agent_server_store::resolve_extension_icon_path(
-        extensions_dir,
-        "extension1",
-        "../extension2/secret.svg",
-    );
-    assert!(
-        result.is_none(),
-        "Path traversal to sibling extension should be blocked"
-    );
-}
-
-#[test]
-fn resolve_extension_icon_path_blocks_absolute_escape() {
-    let temp_dir = tempfile::tempdir().unwrap();
-    let extensions_dir = temp_dir.path();
-    let ext_dir = extensions_dir.join("my-extension");
-    std::fs::create_dir_all(&ext_dir).unwrap();
-
-    // Create a file outside the extensions directory
-    let outside_file = temp_dir.path().join("outside.svg");
-    std::fs::write(&outside_file, "<svg>outside</svg>").unwrap();
-
-    // Try to escape to parent directory
-    let result = project::agent_server_store::resolve_extension_icon_path(
-        extensions_dir,
-        "my-extension",
-        "../outside.svg",
-    );
-    assert!(
-        result.is_none(),
-        "Path traversal to parent directory should be blocked"
-    );
-}
-
-#[test]
-fn resolve_extension_icon_path_blocks_deep_traversal() {
-    let temp_dir = tempfile::tempdir().unwrap();
-    let extensions_dir = temp_dir.path();
-    let ext_dir = extensions_dir.join("my-extension");
-    std::fs::create_dir_all(&ext_dir).unwrap();
-
-    // Try deep path traversal
-    let result = project::agent_server_store::resolve_extension_icon_path(
-        extensions_dir,
-        "my-extension",
-        "../../../../../../etc/passwd",
-    );
-    assert!(
-        result.is_none(),
-        "Deep path traversal should be blocked (file doesn't exist)"
-    );
-}
-
-#[test]
-fn resolve_extension_icon_path_returns_none_for_nonexistent() {
-    let temp_dir = tempfile::tempdir().unwrap();
-    let extensions_dir = temp_dir.path();
-    let ext_dir = extensions_dir.join("my-extension");
-    std::fs::create_dir_all(&ext_dir).unwrap();
-
-    // Try to access a file that doesn't exist
-    let result = project::agent_server_store::resolve_extension_icon_path(
-        extensions_dir,
-        "my-extension",
-        "nonexistent.svg",
-    );
-    assert!(result.is_none(), "Nonexistent file should return None");
-}
diff --git a/crates/project/tests/integration/extension_agent_tests.rs b/crates/project/tests/integration/extension_agent_tests.rs
deleted file mode 100644
index 5af2cd229c4..00000000000
--- a/crates/project/tests/integration/extension_agent_tests.rs
+++ /dev/null
@@ -1,332 +0,0 @@
-use anyhow::Result;
-use collections::HashMap;
-use gpui::{AppContext, AsyncApp, SharedString, Task, TestAppContext};
-use node_runtime::NodeRuntime;
-use project::worktree_store::WorktreeStore;
-use project::{agent_server_store::*, worktree_store::WorktreeIdCounter};
-use std::{any::Any, path::PathBuf, sync::Arc};
-
-#[test]
-fn extension_agent_constructs_proper_display_names() {
-    // Verify the display name format for extension-provided agents
-    let name1 = AgentId(SharedString::from("Extension: Agent"));
-    assert!(name1.0.contains(": "));
-
-    let name2 = AgentId(SharedString::from("MyExt: MyAgent"));
-    assert_eq!(name2.0, "MyExt: MyAgent");
-
-    // Non-extension agents shouldn't have the separator
-    let custom = AgentId(SharedString::from("custom"));
-    assert!(!custom.0.contains(": "));
-}
-
-struct NoopExternalAgent;
-
-impl ExternalAgentServer for NoopExternalAgent {
-    fn get_command(
-        &self,
-        _extra_args: Vec<String>,
-        _extra_env: HashMap<String, String>,
-        _cx: &mut AsyncApp,
-    ) -> Task<Result<AgentServerCommand>> {
-        Task::ready(Ok(AgentServerCommand {
-            path: PathBuf::from("noop"),
-            args: Vec::new(),
-            env: None,
-        }))
-    }
-
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn as_any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-}
-
-#[test]
-fn sync_removes_only_extension_provided_agents() {
-    let mut store = AgentServerStore::collab();
-
-    // Seed with extension agents (contain ": ") and custom agents (don't contain ": ")
-    store.external_agents.insert(
-        AgentId(SharedString::from("Ext1: Agent1")),
-        ExternalAgentEntry::new(
-            Box::new(NoopExternalAgent) as Box<dyn ExternalAgentServer>,
-            ExternalAgentSource::Extension,
-            None,
-            None,
-        ),
-    );
-    store.external_agents.insert(
-        AgentId(SharedString::from("Ext2: Agent2")),
-        ExternalAgentEntry::new(
-            Box::new(NoopExternalAgent) as Box<dyn ExternalAgentServer>,
-            ExternalAgentSource::Extension,
-            None,
-            None,
-        ),
-    );
-    store.external_agents.insert(
-        AgentId(SharedString::from("custom-agent")),
-        ExternalAgentEntry::new(
-            Box::new(NoopExternalAgent) as Box<dyn ExternalAgentServer>,
-            ExternalAgentSource::Custom,
-            None,
-            None,
-        ),
-    );
-
-    // Simulate removal phase
-    store
-        .external_agents
-        .retain(|_, entry| entry.source != ExternalAgentSource::Extension);
-
-    // Only custom-agent should remain
-    assert_eq!(store.external_agents.len(), 1);
-    assert!(
-        store
-            .external_agents
-            .contains_key(&AgentId(SharedString::from("custom-agent")))
-    );
-}
-
-#[test]
-fn archive_launcher_constructs_with_all_fields() {
-    use extension::AgentServerManifestEntry;
-
-    let mut env = HashMap::default();
-    env.insert("GITHUB_TOKEN".into(), "secret".into());
-
-    let mut targets = HashMap::default();
-    targets.insert(
-        "darwin-aarch64".to_string(),
-        extension::TargetConfig {
-            archive:
-                "https://github.com/owner/repo/releases/download/v1.0.0/agent-darwin-arm64.zip"
-                    .into(),
-            cmd: "./agent".into(),
-            args: vec![],
-            sha256: None,
-            env: Default::default(),
-        },
-    );
-
-    let _entry = AgentServerManifestEntry {
-        name: "GitHub Agent".into(),
-        targets,
-        env,
-        icon: None,
-    };
-
-    // Verify display name construction
-    let expected_name = AgentId(SharedString::from("GitHub Agent"));
-    assert_eq!(expected_name.0, "GitHub Agent");
-}
-
-#[gpui::test]
-async fn archive_agent_uses_extension_and_agent_id_for_cache_key(cx: &mut TestAppContext) {
-    let fs = fs::FakeFs::new(cx.background_executor.clone());
-    let http_client = http_client::FakeHttpClient::with_404_response();
-    let worktree_store =
-        cx.new(|cx| WorktreeStore::local(false, fs.clone(), WorktreeIdCounter::get(cx)));
-    let project_environment = cx.new(|cx| {
-        crate::ProjectEnvironment::new(None, worktree_store.downgrade(), None, false, cx)
-    });
-
-    let agent = LocalExtensionArchiveAgent {
-        fs,
-        http_client,
-        node_runtime: node_runtime::NodeRuntime::unavailable(),
-        project_environment,
-        extension_id: Arc::from("my-extension"),
-        agent_id: Arc::from("my-agent"),
-        version: Some(SharedString::from("1.0.0")),
-        targets: {
-            let mut map = HashMap::default();
-            map.insert(
-                "darwin-aarch64".to_string(),
-                extension::TargetConfig {
-                    archive: "https://example.com/my-agent-darwin-arm64.zip".into(),
-                    cmd: "./my-agent".into(),
-                    args: vec!["--serve".into()],
-                    sha256: None,
-                    env: Default::default(),
-                },
-            );
-            map
-        },
-        env: {
-            let mut map = HashMap::default();
-            map.insert("PORT".into(), "8080".into());
-            map
-        },
-        new_version_available_tx: None,
-    };
-
-    // Verify agent is properly constructed
-    assert_eq!(agent.extension_id.as_ref(), "my-extension");
-    assert_eq!(agent.agent_id.as_ref(), "my-agent");
-    assert_eq!(agent.env.get("PORT"), Some(&"8080".to_string()));
-    assert!(agent.targets.contains_key("darwin-aarch64"));
-}
-
-#[test]
-fn sync_extension_agents_registers_archive_launcher() {
-    use extension::AgentServerManifestEntry;
-
-    let expected_name = AgentId(SharedString::from("Release Agent"));
-    assert_eq!(expected_name.0, "Release Agent");
-
-    // Verify the manifest entry structure for archive-based installation
-    let mut env = HashMap::default();
-    env.insert("API_KEY".into(), "secret".into());
-
-    let mut targets = HashMap::default();
-    targets.insert(
-            "linux-x86_64".to_string(),
-            extension::TargetConfig {
-                archive: "https://github.com/org/project/releases/download/v2.1.0/release-agent-linux-x64.tar.gz".into(),
-                cmd: "./release-agent".into(),
-                args: vec!["serve".into()],
-                sha256: None,
-                env: Default::default(),
-            },
-        );
-
-    let manifest_entry = AgentServerManifestEntry {
-        name: "Release Agent".into(),
-        targets: targets.clone(),
-        env,
-        icon: None,
-    };
-
-    // Verify target config is present
-    assert!(manifest_entry.targets.contains_key("linux-x86_64"));
-    let target = manifest_entry.targets.get("linux-x86_64").unwrap();
-    assert_eq!(target.cmd, "./release-agent");
-}
-
-#[gpui::test]
-async fn test_node_command_uses_managed_runtime(cx: &mut TestAppContext) {
-    let fs = fs::FakeFs::new(cx.background_executor.clone());
-    let http_client = http_client::FakeHttpClient::with_404_response();
-    let node_runtime = NodeRuntime::unavailable();
-    let worktree_store =
-        cx.new(|cx| WorktreeStore::local(false, fs.clone(), WorktreeIdCounter::get(cx)));
-    let project_environment = cx.new(|cx| {
-        crate::ProjectEnvironment::new(None, worktree_store.downgrade(), None, false, cx)
-    });
-
-    let agent = LocalExtensionArchiveAgent {
-        fs: fs.clone(),
-        http_client,
-        node_runtime,
-        project_environment,
-        extension_id: Arc::from("node-extension"),
-        agent_id: Arc::from("node-agent"),
-        version: Some(SharedString::from("1.0.0")),
-        targets: {
-            let mut map = HashMap::default();
-            map.insert(
-                "darwin-aarch64".to_string(),
-                extension::TargetConfig {
-                    archive: "https://example.com/node-agent.zip".into(),
-                    cmd: "node".into(),
-                    args: vec!["index.js".into()],
-                    sha256: None,
-                    env: Default::default(),
-                },
-            );
-            map
-        },
-        env: HashMap::default(),
-        new_version_available_tx: None,
-    };
-
-    // Verify that when cmd is "node", it attempts to use the node runtime
-    assert_eq!(agent.extension_id.as_ref(), "node-extension");
-    assert_eq!(agent.agent_id.as_ref(), "node-agent");
-
-    let target = agent.targets.get("darwin-aarch64").unwrap();
-    assert_eq!(target.cmd, "node");
-    assert_eq!(target.args, vec!["index.js"]);
-}
-
-#[gpui::test]
-async fn test_commands_run_in_extraction_directory(cx: &mut TestAppContext) {
-    let fs = fs::FakeFs::new(cx.background_executor.clone());
-    let http_client = http_client::FakeHttpClient::with_404_response();
-    let node_runtime = NodeRuntime::unavailable();
-    let worktree_store =
-        cx.new(|cx| WorktreeStore::local(false, fs.clone(), WorktreeIdCounter::get(cx)));
-    let project_environment = cx.new(|cx| {
-        crate::ProjectEnvironment::new(None, worktree_store.downgrade(), None, false, cx)
-    });
-
-    let agent = LocalExtensionArchiveAgent {
-        fs: fs.clone(),
-        http_client,
-        node_runtime,
-        project_environment,
-        extension_id: Arc::from("test-ext"),
-        agent_id: Arc::from("test-agent"),
-        version: Some(SharedString::from("1.0.0")),
-        targets: {
-            let mut map = HashMap::default();
-            map.insert(
-                "darwin-aarch64".to_string(),
-                extension::TargetConfig {
-                    archive: "https://example.com/test.zip".into(),
-                    cmd: "node".into(),
-                    args: vec![
-                        "server.js".into(),
-                        "--config".into(),
-                        "./config.json".into(),
-                    ],
-                    sha256: None,
-                    env: Default::default(),
-                },
-            );
-            map
-        },
-        env: Default::default(),
-        new_version_available_tx: None,
-    };
-
-    // Verify the agent is configured with relative paths in args
-    let target = agent.targets.get("darwin-aarch64").unwrap();
-    assert_eq!(target.args[0], "server.js");
-    assert_eq!(target.args[2], "./config.json");
-    // These relative paths will resolve relative to the extraction directory
-    // when the command is executed
-}
-
-#[test]
-fn test_tilde_expansion_in_settings() {
-    let settings = settings::CustomAgentServerSettings::Custom {
-        path: PathBuf::from("~/custom/agent"),
-        args: vec!["serve".into()],
-        env: Default::default(),
-        default_mode: None,
-        default_model: None,
-        favorite_models: vec![],
-        default_config_options: Default::default(),
-        favorite_config_option_values: Default::default(),
-    };
-
-    let converted: CustomAgentServerSettings = settings.into();
-    let CustomAgentServerSettings::Custom {
-        command: AgentServerCommand { path, .. },
-        ..
-    } = converted
-    else {
-        panic!("Expected Custom variant");
-    };
-
-    assert!(
-        !path.to_string_lossy().starts_with("~"),
-        "Tilde should be expanded for custom agent path"
-    );
-}
diff --git a/crates/project/tests/integration/project_tests.rs b/crates/project/tests/integration/project_tests.rs
index b93dd8a7274..be3a278a662 100644
--- a/crates/project/tests/integration/project_tests.rs
+++ b/crates/project/tests/integration/project_tests.rs
@@ -5,8 +5,6 @@ mod bookmark_store;
 mod color_extractor;
 mod context_server_store;
 mod debugger;
-mod ext_agent_tests;
-mod extension_agent_tests;
 mod git_store;
 mod image_store;
 mod lsp_command;
diff --git a/crates/settings_content/src/agent.rs b/crates/settings_content/src/agent.rs
index 1a1d4fc6423..d5169b25634 100644
--- a/crates/settings_content/src/agent.rs
+++ b/crates/settings_content/src/agent.rs
@@ -523,46 +523,8 @@ pub enum CustomAgentServerSettings {
         #[serde(default, skip_serializing_if = "HashMap::is_empty")]
         favorite_config_option_values: HashMap<String, Vec<String>>,
     },
-    Extension {
-        /// Additional environment variables to pass to the agent.
-        ///
-        /// Default: {}
-        #[serde(default, skip_serializing_if = "HashMap::is_empty")]
-        env: HashMap<String, String>,
-        /// The default mode to use for this agent.
-        ///
-        /// Note: Not only all agents support modes.
-        ///
-        /// Default: None
-        default_mode: Option<String>,
-        /// The default model to use for this agent.
-        ///
-        /// This should be the model ID as reported by the agent.
-        ///
-        /// Default: None
-        default_model: Option<String>,
-        /// The favorite models for this agent.
-        ///
-        /// These are the model IDs as reported by the agent.
-        ///
-        /// Default: []
-        #[serde(default, skip_serializing_if = "Vec::is_empty")]
-        favorite_models: Vec<String>,
-        /// Default values for session config options.
-        ///
-        /// This is a map from config option ID to value ID.
-        ///
-        /// Default: {}
-        #[serde(default, skip_serializing_if = "HashMap::is_empty")]
-        default_config_options: HashMap<String, String>,
-        /// Favorited values for session config options.
-        ///
-        /// This is a map from config option ID to a list of favorited value IDs.
-        ///
-        /// Default: {}
-        #[serde(default, skip_serializing_if = "HashMap::is_empty")]
-        favorite_config_option_values: HashMap<String, Vec<String>>,
-    },
+    // Used for the ACP extension migration
+    #[serde(alias = "extension")]
     Registry {
         /// Additional environment variables to pass to the agent.
         ///
diff --git a/crates/zed_actions/src/lib.rs b/crates/zed_actions/src/lib.rs
index 8390cda86c7..1c6bcec766e 100644
--- a/crates/zed_actions/src/lib.rs
+++ b/crates/zed_actions/src/lib.rs
@@ -87,7 +87,6 @@ pub enum ExtensionCategoryFilter {
     Grammars,
     LanguageServers,
     ContextServers,
-    AgentServers,
     Snippets,
     DebugAdapters,
 }

From 97c25c31e450dd65ca2ef9b3929fb489c71e34e0 Mon Sep 17 00:00:00 2001
From: Cynthia Rey <cynthia@cynthia.dev>
Date: Thu, 21 May 2026 11:16:40 +0200
Subject: [PATCH 079/105] zed: Make "About" window floating (#57307)

The about window currently is a "Normal" window, which is suboptimal on
tiling window managers.

This changes it to be a floating window, causing less disruptions to
opinionated WM layouts.

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Release Notes:

- Fixed the "About Zed" dialog being a full window instead of a floating
window.
---
 crates/zed/src/zed.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs
index 17c910ab024..9bfdd9b1fde 100644
--- a/crates/zed/src/zed.rs
+++ b/crates/zed/src/zed.rs
@@ -1551,7 +1551,7 @@ fn open_about_window(cx: &mut App) {
             window_bounds: Some(WindowBounds::centered(window_size, cx)),
             is_resizable: false,
             is_minimizable: false,
-            kind: WindowKind::Normal,
+            kind: WindowKind::Floating,
             app_id: Some(ReleaseChannel::global(cx).app_id().to_owned()),
             ..Default::default()
         },

From b13849d04f6cb69e7ed7975f6fb188fd86f3a37e Mon Sep 17 00:00:00 2001
From: Ben Brandt <benjamin.j.brandt@gmail.com>
Date: Thu, 21 May 2026 12:00:29 +0200
Subject: [PATCH 080/105] google: Add Google thinking level support (#57358)

Also makes sure we are properly catching and processing thinking events.

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Release Notes:

- google: Support thinking levels for Google models.
---
 crates/google_ai/src/completion.rs            | 381 ++++++++++++++++--
 crates/google_ai/src/google_ai.rs             | 110 ++++-
 crates/language_models/src/provider/google.rs |  23 +-
 3 files changed, 452 insertions(+), 62 deletions(-)

diff --git a/crates/google_ai/src/completion.rs b/crates/google_ai/src/completion.rs
index b96679cfbc1..862e9f08fb7 100644
--- a/crates/google_ai/src/completion.rs
+++ b/crates/google_ai/src/completion.rs
@@ -12,8 +12,8 @@ use std::sync::atomic::{self, AtomicU64};
 use crate::{
     Content, FunctionCallingConfig, FunctionCallingMode, FunctionDeclaration,
     GenerateContentResponse, GenerationConfig, GenerativeContentBlob, GoogleModelMode,
-    InlineDataPart, ModelName, Part, SystemInstruction, TextPart, ThinkingConfig, ToolConfig,
-    UsageMetadata,
+    InlineDataPart, ModelName, Part, SystemInstruction, TextPart, ThinkingConfig, ThinkingLevel,
+    ToolConfig, UsageMetadata,
 };
 
 pub fn into_google(
@@ -27,19 +27,24 @@ pub fn into_google(
             .flat_map(|content| match content {
                 MessageContent::Text(text) => {
                     if !text.is_empty() {
-                        vec![Part::TextPart(TextPart { text })]
+                        vec![Part::TextPart(TextPart {
+                            text,
+                            thought: false,
+                            thought_signature: None,
+                        })]
                     } else {
                         vec![]
                     }
                 }
                 MessageContent::Thinking {
-                    text: _,
+                    text,
                     signature: Some(signature),
                 } => {
                     if !signature.is_empty() {
-                        vec![Part::ThoughtPart(crate::ThoughtPart {
+                        vec![Part::TextPart(TextPart {
+                            text,
                             thought: true,
-                            thought_signature: signature,
+                            thought_signature: Some(signature),
                         })]
                     } else {
                         vec![]
@@ -110,6 +115,8 @@ pub fn into_google(
             .collect()
     }
 
+    let thinking_config = thinking_config_for_request(&request, &model_id, mode);
+
     let system_instructions = if request
         .messages
         .first()
@@ -150,32 +157,7 @@ pub fn into_google(
             stop_sequences: Some(request.stop),
             max_output_tokens: None,
             temperature: request.temperature.map(|t| t as f64),
-            thinking_config: match (request.thinking_allowed, mode) {
-                (true, GoogleModelMode::Thinking { budget_tokens }) => {
-                    let effort = request.thinking_effort.as_deref().map(|s| s.to_lowercase());
-                    let thinking_level = match effort.as_deref() {
-                        Some("high") => Some(crate::ThinkingLevel::High),
-                        Some("medium") => Some(crate::ThinkingLevel::Medium),
-                        Some("low") => Some(crate::ThinkingLevel::Low),
-                        Some("minimal") => Some(crate::ThinkingLevel::Minimal),
-                        _ => None,
-                    };
-
-                    Some(ThinkingConfig {
-                        thinking_budget: budget_tokens,
-                        thinking_level,
-                    })
-                    .filter(
-                        |ThinkingConfig {
-                             thinking_budget,
-                             thinking_level,
-                         }| {
-                            thinking_level.is_some() || thinking_budget.is_some()
-                        },
-                    )
-                }
-                _ => None,
-            },
+            thinking_config,
             top_p: None,
             top_k: None,
         }),
@@ -206,6 +188,76 @@ pub fn into_google(
     }
 }
 
+fn thinking_config_for_request(
+    request: &LanguageModelRequest,
+    model_id: &str,
+    mode: GoogleModelMode,
+) -> Option<ThinkingConfig> {
+    let supports_thinking =
+        matches!(mode, GoogleModelMode::Thinking { .. }) || is_google_thinking_model(model_id);
+    if !supports_thinking {
+        return None;
+    }
+
+    let mut config = ThinkingConfig::default();
+
+    if request.thinking_allowed {
+        config.include_thoughts = Some(true);
+        config.thinking_level = request
+            .thinking_effort
+            .as_deref()
+            .and_then(ThinkingLevel::from_effort);
+
+        if config.thinking_level.is_none()
+            && let GoogleModelMode::Thinking {
+                budget_tokens: Some(budget_tokens),
+            } = mode
+        {
+            config.thinking_budget = Some(budget_tokens);
+        }
+    } else if let Some(thinking_level) = disabled_thinking_level(model_id) {
+        config.thinking_level = Some(thinking_level);
+    } else if supports_thinking_budget_disable(model_id) {
+        config.thinking_budget = Some(0);
+    }
+
+    (!config.is_empty()).then_some(config)
+}
+
+impl ThinkingConfig {
+    fn is_empty(&self) -> bool {
+        self.thinking_budget.is_none()
+            && self.thinking_level.is_none()
+            && self.include_thoughts.is_none()
+    }
+}
+
+fn is_google_thinking_model(model_id: &str) -> bool {
+    model_id.starts_with("gemini-2.5-") || model_id.starts_with("gemini-3")
+}
+
+fn disabled_thinking_level(model_id: &str) -> Option<ThinkingLevel> {
+    match model_id {
+        model_id if model_id.starts_with("gemini-3") && model_id.contains("-pro") => {
+            Some(ThinkingLevel::Low)
+        }
+        model_id if model_id.starts_with("gemini-3") => Some(ThinkingLevel::Minimal),
+        _ => None,
+    }
+}
+
+fn supports_thinking_budget_disable(model_id: &str) -> bool {
+    matches!(
+        model_id,
+        "gemini-2.5-flash"
+            | "gemini-2.5-flash-lite"
+            | "gemini-2.5-flash-preview-latest"
+            | "gemini-2.5-flash-preview-04-17"
+            | "gemini-2.5-flash-preview-05-20"
+            | "gemini-2.5-flash-lite-preview-06-17"
+    )
+}
+
 pub struct GoogleEventMapper {
     usage: UsageMetadata,
     stop_reason: StopReason,
@@ -276,6 +328,23 @@ impl GoogleEventMapper {
                     self.stop_reason = match finish_reason {
                         "STOP" => StopReason::EndTurn,
                         "MAX_TOKENS" => StopReason::MaxTokens,
+                        "SAFETY"
+                        | "RECITATION"
+                        | "LANGUAGE"
+                        | "OTHER"
+                        | "BLOCKLIST"
+                        | "PROHIBITED_CONTENT"
+                        | "SPII"
+                        | "MALFORMED_FUNCTION_CALL"
+                        | "IMAGE_SAFETY"
+                        | "IMAGE_PROHIBITED_CONTENT"
+                        | "IMAGE_OTHER"
+                        | "NO_IMAGE"
+                        | "IMAGE_RECITATION"
+                        | "UNEXPECTED_TOOL_CALL"
+                        | "TOO_MANY_TOOL_CALLS"
+                        | "MISSING_THOUGHT_SIGNATURE"
+                        | "MALFORMED_RESPONSE" => StopReason::Refusal,
                         _ => {
                             log::error!("Unexpected google finish_reason: {finish_reason}");
                             StopReason::EndTurn
@@ -288,7 +357,28 @@ impl GoogleEventMapper {
                     .into_iter()
                     .for_each(|part| match part {
                         Part::TextPart(text_part) => {
-                            events.push(Ok(LanguageModelCompletionEvent::Text(text_part.text)))
+                            let thought_signature =
+                                text_part.thought_signature.filter(|s| !s.is_empty());
+                            if text_part.thought {
+                                if !text_part.text.is_empty() || thought_signature.is_some() {
+                                    events.push(Ok(LanguageModelCompletionEvent::Thinking {
+                                        text: text_part.text,
+                                        signature: thought_signature,
+                                    }))
+                                }
+                            } else {
+                                if let Some(thought_signature) = thought_signature {
+                                    events.push(Ok(LanguageModelCompletionEvent::Thinking {
+                                        text: String::new(),
+                                        signature: Some(thought_signature),
+                                    }));
+                                }
+                                if !text_part.text.is_empty() {
+                                    events.push(Ok(LanguageModelCompletionEvent::Text(
+                                        text_part.text,
+                                    )));
+                                }
+                            }
                         }
                         Part::InlineDataPart(_) => {}
                         Part::FunctionCallPart(function_call_part) => {
@@ -320,12 +410,6 @@ impl GoogleEventMapper {
                             )));
                         }
                         Part::FunctionResponsePart(_) => {}
-                        Part::ThoughtPart(part) => {
-                            events.push(Ok(LanguageModelCompletionEvent::Thinking {
-                                text: "(Encrypted thought)".to_string(), // TODO: Can we populate this from thought summaries?
-                                signature: Some(part.thought_signature),
-                            }));
-                        }
                     });
             }
         }
@@ -382,8 +466,227 @@ mod tests {
         Content, FunctionCall, FunctionCallPart, GenerateContentCandidate, GenerateContentResponse,
         Part, Role as GoogleRole,
     };
+    use language_model_core::LanguageModelRequestMessage;
     use serde_json::json;
 
+    fn text_request() -> LanguageModelRequest {
+        LanguageModelRequest {
+            messages: vec![LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec![MessageContent::Text("Hello".to_string())],
+                cache: false,
+                reasoning_details: None,
+            }],
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn into_google_requests_thought_summaries_and_thinking_level() {
+        let mut request = text_request();
+        request.thinking_allowed = true;
+        request.thinking_effort = Some("low".to_string());
+
+        let request = into_google(
+            request,
+            "gemini-3.5-flash".to_string(),
+            GoogleModelMode::Thinking {
+                budget_tokens: None,
+            },
+        );
+
+        let thinking_config = request.generation_config.unwrap().thinking_config.unwrap();
+        assert_eq!(thinking_config.include_thoughts, Some(true));
+        assert_eq!(thinking_config.thinking_level, Some(ThinkingLevel::Low));
+
+        let serialized = serde_json::to_value(thinking_config).unwrap();
+        assert_eq!(serialized["thinkingLevel"], "LOW");
+        assert_eq!(serialized["includeThoughts"], true);
+    }
+
+    #[test]
+    fn into_google_turns_off_budget_thinking_when_supported() {
+        let mut request = text_request();
+        request.thinking_allowed = false;
+
+        let request = into_google(
+            request,
+            "gemini-2.5-flash".to_string(),
+            GoogleModelMode::Thinking {
+                budget_tokens: None,
+            },
+        );
+
+        let thinking_config = request.generation_config.unwrap().thinking_config.unwrap();
+        assert_eq!(thinking_config.thinking_budget, Some(0));
+        assert_eq!(thinking_config.include_thoughts, None);
+    }
+
+    #[test]
+    fn into_google_uses_minimal_level_when_gemini_3_flash_thinking_is_off() {
+        let mut request = text_request();
+        request.thinking_allowed = false;
+
+        let request = into_google(
+            request,
+            "gemini-3.5-flash".to_string(),
+            GoogleModelMode::Thinking {
+                budget_tokens: None,
+            },
+        );
+
+        let thinking_config = request.generation_config.unwrap().thinking_config.unwrap();
+        assert_eq!(thinking_config.thinking_level, Some(ThinkingLevel::Minimal));
+        assert_eq!(thinking_config.include_thoughts, None);
+    }
+
+    #[test]
+    fn into_google_replays_signed_thinking_as_thought_text_part() {
+        let request = LanguageModelRequest {
+            messages: vec![LanguageModelRequestMessage {
+                role: Role::Assistant,
+                content: vec![MessageContent::Thinking {
+                    text: "summary".to_string(),
+                    signature: Some("signature".to_string()),
+                }],
+                cache: false,
+                reasoning_details: None,
+            }],
+            ..Default::default()
+        };
+
+        let request = into_google(
+            request,
+            "gemini-3.5-flash".to_string(),
+            GoogleModelMode::Thinking {
+                budget_tokens: None,
+            },
+        );
+
+        let Part::TextPart(text_part) = &request.contents[0].parts[0] else {
+            panic!("expected text part");
+        };
+        assert_eq!(text_part.text, "summary");
+        assert!(text_part.thought);
+        assert_eq!(text_part.thought_signature.as_deref(), Some("signature"));
+    }
+
+    #[test]
+    fn thought_text_part_deserializes_and_maps_to_thinking_event() {
+        let part: Part = serde_json::from_value(json!({
+            "text": "checking the constraints",
+            "thought": true,
+            "thoughtSignature": "thought-signature"
+        }))
+        .unwrap();
+
+        let mut mapper = GoogleEventMapper::new();
+        let response = GenerateContentResponse {
+            candidates: Some(vec![GenerateContentCandidate {
+                index: Some(0),
+                content: Content {
+                    parts: vec![part],
+                    role: GoogleRole::Model,
+                },
+                finish_reason: None,
+                finish_message: None,
+                safety_ratings: None,
+                citation_metadata: None,
+            }]),
+            prompt_feedback: None,
+            usage_metadata: None,
+        };
+
+        let events = mapper.map_event(response);
+        assert_eq!(events.len(), 1);
+        assert!(matches!(
+            &events[0],
+            Ok(LanguageModelCompletionEvent::Thinking { text, signature })
+                if text == "checking the constraints"
+                    && signature.as_deref() == Some("thought-signature")
+        ));
+    }
+
+    #[test]
+    fn signed_non_thought_text_part_preserves_signature() {
+        let part: Part = serde_json::from_value(json!({
+            "text": "visible text",
+            "thoughtSignature": "visible-signature"
+        }))
+        .unwrap();
+
+        let Part::TextPart(text_part) = part else {
+            panic!("expected text part");
+        };
+        assert_eq!(text_part.text, "visible text");
+        assert!(!text_part.thought);
+        assert_eq!(
+            text_part.thought_signature.as_deref(),
+            Some("visible-signature")
+        );
+    }
+
+    #[test]
+    fn signed_non_thought_text_part_maps_signature_carrier() {
+        let part: Part = serde_json::from_value(json!({
+            "text": "visible text",
+            "thoughtSignature": "visible-signature"
+        }))
+        .unwrap();
+
+        let mut mapper = GoogleEventMapper::new();
+        let response = GenerateContentResponse {
+            candidates: Some(vec![GenerateContentCandidate {
+                index: Some(0),
+                content: Content {
+                    parts: vec![part],
+                    role: GoogleRole::Model,
+                },
+                finish_reason: None,
+                finish_message: None,
+                safety_ratings: None,
+                citation_metadata: None,
+            }]),
+            prompt_feedback: None,
+            usage_metadata: None,
+        };
+
+        let events = mapper.map_event(response);
+        assert_eq!(events.len(), 2);
+        assert!(matches!(
+            &events[0],
+            Ok(LanguageModelCompletionEvent::Thinking { text, signature })
+                if text.is_empty() && signature.as_deref() == Some("visible-signature")
+        ));
+        assert!(matches!(
+            &events[1],
+            Ok(LanguageModelCompletionEvent::Text(text)) if text == "visible text"
+        ));
+    }
+
+    #[test]
+    fn safety_finish_reason_is_refusal() {
+        let mut mapper = GoogleEventMapper::new();
+        let response = GenerateContentResponse {
+            candidates: Some(vec![GenerateContentCandidate {
+                index: Some(0),
+                content: Content {
+                    parts: Vec::new(),
+                    role: GoogleRole::Model,
+                },
+                finish_reason: Some("SAFETY".to_string()),
+                finish_message: None,
+                safety_ratings: None,
+                citation_metadata: None,
+            }]),
+            prompt_feedback: None,
+            usage_metadata: None,
+        };
+
+        mapper.map_event(response);
+        assert_eq!(mapper.stop_reason, StopReason::Refusal);
+    }
+
     #[test]
     fn test_function_call_with_signature_creates_tool_use_with_signature() {
         let mut mapper = GoogleEventMapper::new();
diff --git a/crates/google_ai/src/google_ai.rs b/crates/google_ai/src/google_ai.rs
index 305f43ab3a3..56ec48c83a8 100644
--- a/crates/google_ai/src/google_ai.rs
+++ b/crates/google_ai/src/google_ai.rs
@@ -166,17 +166,24 @@ pub enum Role {
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum Part {
-    TextPart(TextPart),
-    InlineDataPart(InlineDataPart),
     FunctionCallPart(FunctionCallPart),
     FunctionResponsePart(FunctionResponsePart),
-    ThoughtPart(ThoughtPart),
+    InlineDataPart(InlineDataPart),
+    TextPart(TextPart),
+}
+
+fn is_false(value: &bool) -> bool {
+    !*value
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct TextPart {
     pub text: String,
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub thought: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub thought_signature: Option<String>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -208,13 +215,6 @@ pub struct FunctionResponsePart {
     pub function_response: FunctionResponse,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ThoughtPart {
-    pub thought: bool,
-    pub thought_signature: String,
-}
-
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CitationSource {
@@ -261,16 +261,18 @@ pub struct UsageMetadata {
     pub total_token_count: Option<u64>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Default)]
 #[serde(rename_all = "camelCase")]
 pub struct ThinkingConfig {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub thinking_budget: Option<u32>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub thinking_level: Option<ThinkingLevel>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub include_thoughts: Option<bool>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "UPPERCASE")]
 pub enum ThinkingLevel {
     Minimal,
@@ -279,6 +281,36 @@ pub enum ThinkingLevel {
     High,
 }
 
+impl ThinkingLevel {
+    pub fn from_effort(effort: &str) -> Option<Self> {
+        match effort.to_lowercase().as_str() {
+            "minimal" => Some(Self::Minimal),
+            "low" => Some(Self::Low),
+            "medium" => Some(Self::Medium),
+            "high" => Some(Self::High),
+            _ => None,
+        }
+    }
+
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Minimal => "Minimal",
+            Self::Low => "Low",
+            Self::Medium => "Medium",
+            Self::High => "High",
+        }
+    }
+
+    pub fn value(self) -> &'static str {
+        match self {
+            Self::Minimal => "minimal",
+            Self::Low => "low",
+            Self::Medium => "medium",
+            Self::High => "high",
+        }
+    }
+}
+
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct GenerationConfig {
@@ -579,6 +611,50 @@ impl Model {
         true
     }
 
+    pub fn supports_thinking(&self) -> bool {
+        matches!(
+            self,
+            Self::Gemini25FlashLite
+                | Self::Gemini25Flash
+                | Self::Gemini25Pro
+                | Self::Gemini31FlashLite
+                | Self::Gemini3Flash
+                | Self::Gemini35Flash
+                | Self::Gemini31Pro
+                | Self::Custom {
+                    mode: GoogleModelMode::Thinking { .. },
+                    ..
+                }
+        )
+    }
+
+    pub fn supported_thinking_levels(&self) -> &'static [ThinkingLevel] {
+        match self {
+            Self::Gemini31FlashLite | Self::Gemini3Flash | Self::Gemini35Flash => &[
+                ThinkingLevel::Minimal,
+                ThinkingLevel::Low,
+                ThinkingLevel::Medium,
+                ThinkingLevel::High,
+            ],
+            Self::Gemini31Pro => &[
+                ThinkingLevel::Low,
+                ThinkingLevel::Medium,
+                ThinkingLevel::High,
+            ],
+            _ => &[],
+        }
+    }
+
+    pub fn default_thinking_level(&self) -> Option<ThinkingLevel> {
+        match self {
+            Self::Gemini31FlashLite => Some(ThinkingLevel::Minimal),
+            Self::Gemini3Flash => Some(ThinkingLevel::High),
+            Self::Gemini35Flash => Some(ThinkingLevel::Medium),
+            Self::Gemini31Pro => Some(ThinkingLevel::High),
+            _ => None,
+        }
+    }
+
     pub fn mode(&self) -> GoogleModelMode {
         match self {
             Self::Gemini25FlashLite | Self::Gemini25Flash | Self::Gemini25Pro => {
@@ -588,12 +664,10 @@ impl Model {
                     budget_tokens: None,
                 }
             }
-            Self::Gemini3Flash => GoogleModelMode::Default,
-            Self::Gemini31FlashLite => GoogleModelMode::Default,
-            Self::Gemini35Flash => GoogleModelMode::Thinking {
-                budget_tokens: None,
-            },
-            Self::Gemini31Pro => GoogleModelMode::Thinking {
+            Self::Gemini31FlashLite
+            | Self::Gemini3Flash
+            | Self::Gemini35Flash
+            | Self::Gemini31Pro => GoogleModelMode::Thinking {
                 budget_tokens: None,
             },
             Self::Custom { mode, .. } => *mode,
diff --git a/crates/language_models/src/provider/google.rs b/crates/language_models/src/provider/google.rs
index d5b47bf4583..774de74a6b2 100644
--- a/crates/language_models/src/provider/google.rs
+++ b/crates/language_models/src/provider/google.rs
@@ -2,8 +2,8 @@ use anyhow::{Context as _, Result};
 use collections::BTreeMap;
 use credentials_provider::CredentialsProvider;
 use futures::{FutureExt, StreamExt, future::BoxFuture};
+use google_ai::GenerateContentResponse;
 pub use google_ai::completion::{GoogleEventMapper, into_google};
-use google_ai::{GenerateContentResponse, GoogleModelMode};
 use gpui::{AnyView, App, AsyncApp, Context, Entity, SharedString, Task, TaskExt, Window};
 use http_client::HttpClient;
 use language_model::{
@@ -11,9 +11,9 @@ use language_model::{
     LanguageModelCompletionEvent, LanguageModelToolChoice, LanguageModelToolSchemaFormat,
 };
 use language_model::{
-    GOOGLE_PROVIDER_ID, GOOGLE_PROVIDER_NAME, IconOrSvg, LanguageModel, LanguageModelId,
-    LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName,
-    LanguageModelProviderState, LanguageModelRequest, RateLimiter,
+    GOOGLE_PROVIDER_ID, GOOGLE_PROVIDER_NAME, IconOrSvg, LanguageModel, LanguageModelEffortLevel,
+    LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId,
+    LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, RateLimiter,
 };
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -300,7 +300,20 @@ impl LanguageModel for GoogleLanguageModel {
     }
 
     fn supports_thinking(&self) -> bool {
-        matches!(self.model.mode(), GoogleModelMode::Thinking { .. })
+        self.model.supports_thinking()
+    }
+
+    fn supported_effort_levels(&self) -> Vec<LanguageModelEffortLevel> {
+        let default_level = self.model.default_thinking_level();
+        self.model
+            .supported_thinking_levels()
+            .iter()
+            .map(|level| LanguageModelEffortLevel {
+                name: level.name().into(),
+                value: level.value().into(),
+                is_default: Some(*level) == default_level,
+            })
+            .collect()
     }
 
     fn supports_tool_choice(&self, choice: LanguageModelToolChoice) -> bool {

From f15d759bf6dd7c03c0c2518557cbf8886ce4277f Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Thu, 21 May 2026 12:43:45 +0200
Subject: [PATCH 081/105] Update single file review docs (#57375)

Release Notes:

- N/A

---------

Co-authored-by: Akrm Al-Hakimi <alk9fh@bosch.com>
---
 crates/settings_content/src/agent.rs |  2 +-
 docs/src/ai/agent-panel.md           | 13 ++++++++++---
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/crates/settings_content/src/agent.rs b/crates/settings_content/src/agent.rs
index d5169b25634..917ca5e0530 100644
--- a/crates/settings_content/src/agent.rs
+++ b/crates/settings_content/src/agent.rs
@@ -151,7 +151,7 @@ pub struct AgentSettingsContent {
     pub play_sound_when_agent_done: Option<PlaySoundWhenAgentDone>,
     /// Whether to display agent edits in single-file editors in addition to the review multibuffer pane.
     ///
-    /// Default: true
+    /// Default: false
     pub single_file_review: Option<bool>,
     /// Additional parameters for language model requests. When making a request
     /// to a model, parameters will be taken from the last entry in this list
diff --git a/docs/src/ai/agent-panel.md b/docs/src/ai/agent-panel.md
index 95588b025f2..df3cafb1e82 100644
--- a/docs/src/ai/agent-panel.md
+++ b/docs/src/ai/agent-panel.md
@@ -120,9 +120,16 @@ To see which files specifically have been edited, expand the accordion bar that
 
 You can accept or reject each individual change hunk, or the whole set of changes made by the agent.
 
-Edit diffs also appear in singleton buffers.
-If your active tab had edits made by the AI, you'll see diffs with the same accept/reject controls as in the multi-buffer.
-You can turn this off, though, through the `agent.single_file_review` setting.
+Edit diffs can also appear inline in individual files with the same
+keep/reject hunk controls as the multi-buffer review pane. This temporarily overrides the buffer's git diff while review is active. Enable it by setting `agent.single_file_review` to `true` in your settings:
+
+```json
+{
+  "agent": {
+    "single_file_review": true
+  }
+}
+```
 
 ## Terminal Threads {#terminal-threads}
 

From 0ec218fa5fde44b258aac60e1086dc5bf5bbdbfb Mon Sep 17 00:00:00 2001
From: hollmmax <hollmannm1@gmail.com>
Date: Thu, 21 May 2026 12:43:52 +0200
Subject: [PATCH 082/105] settings_ui: Respect window decorations setting
 (#57371)

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [ ] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Closes #57370

Release Notes:

- Server-side window decorations now also apply to the settings window.
---
 crates/settings_ui/src/settings_ui.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/crates/settings_ui/src/settings_ui.rs b/crates/settings_ui/src/settings_ui.rs
index 02bbacdfa30..5f9d323746e 100644
--- a/crates/settings_ui/src/settings_ui.rs
+++ b/crates/settings_ui/src/settings_ui.rs
@@ -42,7 +42,8 @@ use ui::{
 
 use util::{ResultExt as _, paths::PathStyle, rel_path::RelPath};
 use workspace::{
-    AppState, MultiWorkspace, OpenOptions, OpenVisible, Workspace, client_side_decorations,
+    AppState, MultiWorkspace, OpenOptions, OpenVisible, Workspace, WorkspaceSettings,
+    client_side_decorations,
 };
 use zed_actions::{OpenProjectSettings, OpenSettings, OpenSettingsAt};
 
@@ -662,7 +663,10 @@ pub fn open_settings_editor(
         let window_decorations = match std::env::var("ZED_WINDOW_DECORATIONS") {
             Ok(val) if val == "server" => gpui::WindowDecorations::Server,
             Ok(val) if val == "client" => gpui::WindowDecorations::Client,
-            _ => gpui::WindowDecorations::Client,
+            _ => match WorkspaceSettings::get_global(cx).window_decorations {
+                settings::WindowDecorations::Server => gpui::WindowDecorations::Server,
+                settings::WindowDecorations::Client => gpui::WindowDecorations::Client,
+            },
         };
 
         cx.open_window(

From 70733ceb6e1dd8079030bdebfb062f92ce4809b4 Mon Sep 17 00:00:00 2001
From: Aaron Ang <aaronang@users.noreply.github.com>
Date: Thu, 21 May 2026 04:07:12 -0700
Subject: [PATCH 083/105] git_graph: Show full commit message in tooltip on
 hover (#57032)

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [ ] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Closes #56903

Release Notes:

- Improved commit tooltip in Git Graph.

## Screenshots

Showing full commit message:

<img width="3024" height="1898" alt="CleanShot 2026-05-17 at 21 59
35@2x"
src="https://github.com/user-attachments/assets/503ca832-fc07-4f90-961f-a9c4e25fcba2"
/>

Truncating messages with more than 800 characters:

<img width="1536" height="1096" alt="CleanShot 2026-05-17 at 22 12 07"
src="https://github.com/user-attachments/assets/314be9a9-0aaa-44ff-aa15-de5eb38c863a"
/>


## Alternative

One thing I was considering is whether we should be using a
`HoverPopover` instead so that the preview is wider and we don't have to
truncate the commit message body. I would love to hear your thoughts on
this. For now, I stuck with the `Tooltip` for simplicity reasons.

<img width="3024" height="1896" alt="CleanShot 2026-05-17 at 22 04
39@2x"
src="https://github.com/user-attachments/assets/5b8806f6-3dce-4675-9150-df9257ad6269"
/>

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
Co-authored-by: Smit Barmase <heysmitbarmase@gmail.com>
---
 crates/git_graph/src/git_graph.rs   | 54 ++++++++++++++++++++++++++---
 crates/git_ui/src/commit_tooltip.rs | 21 +++++------
 2 files changed, 60 insertions(+), 15 deletions(-)

diff --git a/crates/git_graph/src/git_graph.rs b/crates/git_graph/src/git_graph.rs
index 605c5956635..80acde23c2d 100644
--- a/crates/git_graph/src/git_graph.rs
+++ b/crates/git_graph/src/git_graph.rs
@@ -2,6 +2,7 @@ use collections::{BTreeMap, HashMap, IndexSet};
 use editor::Editor;
 use git::{
     BuildCommitPermalinkParams, GitHostingProviderRegistry, GitRemote, Oid, ParsedGitRemote,
+    commit::ParsedCommitMessage,
     parse_git_remote_url,
     repository::{
         CommitDiff, CommitFile, InitialGraphCommitData, LogOrder, LogSource, RepoPath,
@@ -9,7 +10,11 @@ use git::{
     },
     status::{FileStatus, StatusCode, TrackedStatus},
 };
-use git_ui::{commit_tooltip::CommitAvatar, commit_view::CommitView, git_status_icon};
+use git_ui::{
+    commit_tooltip::{CommitAvatar, CommitDetails, CommitTooltip},
+    commit_view::CommitView,
+    git_status_icon,
+};
 use gpui::{
     Action, Anchor, AnyElement, App, Bounds, ClickEvent, ClipboardItem, DefiniteLength,
     DismissEvent, DragMoveEvent, ElementId, Empty, Entity, EventEmitter, FocusHandle, Focusable,
@@ -1539,7 +1544,7 @@ impl GitGraph {
                 let subject: SharedString;
                 let author_name: SharedString;
 
-                if let CommitDataState::Loaded(data) = data {
+                if let CommitDataState::Loaded(ref data) = data {
                     subject = data.subject.clone();
                     author_name = data.author_name.clone();
                     formatted_time = format_timestamp(data.commit_timestamp);
@@ -1594,12 +1599,12 @@ impl GitGraph {
                             (!ranges.is_empty()).then_some(ranges)
                         })
                         .unwrap_or_default();
-                    HighlightedLabel::from_ranges(subject.clone(), highlight_ranges)
+                    HighlightedLabel::from_ranges(subject, highlight_ranges)
                         .when(!is_selected, |c| c.color(Color::Muted))
                         .truncate()
                         .into_any_element()
                 } else {
-                    column_label(subject.clone())
+                    column_label(subject)
                 };
 
                 vec![
@@ -1607,7 +1612,46 @@ impl GitGraph {
                         .id(ElementId::NamedInteger("commit-subject".into(), idx as u64))
                         .overflow_hidden()
                         .when(!has_context_menu, |this| {
-                            this.tooltip(Tooltip::text(subject))
+                            if let CommitDataState::Loaded(commit_data) = &data {
+                                let sha = commit.data.sha.to_string();
+                                let author_name = commit_data.author_name.clone();
+                                let author_email = commit_data.author_email.clone();
+                                let message = commit_data.message.clone();
+                                let commit_timestamp = commit_data.commit_timestamp;
+                                let workspace = self.workspace.clone();
+                                let repository = repository.clone();
+                                this.hoverable_tooltip(move |_window, cx| {
+                                    let remote_url = repository.read(cx).default_remote_url();
+                                    let provider_registry =
+                                        GitHostingProviderRegistry::default_global(cx);
+                                    let commit_details = CommitDetails {
+                                        sha: sha.clone().into(),
+                                        author_name: author_name.clone(),
+                                        author_email: author_email.clone(),
+                                        commit_time: OffsetDateTime::from_unix_timestamp(
+                                            commit_timestamp,
+                                        )
+                                        .unwrap_or_else(|_| OffsetDateTime::now_utc()),
+                                        message: Some(ParsedCommitMessage::parse(
+                                            sha.clone(),
+                                            message.to_string(),
+                                            remote_url.as_deref(),
+                                            Some(provider_registry),
+                                        )),
+                                    };
+                                    cx.new(|cx| {
+                                        CommitTooltip::new(
+                                            commit_details,
+                                            repository.clone(),
+                                            workspace.clone(),
+                                            cx,
+                                        )
+                                    })
+                                    .into()
+                                })
+                            } else {
+                                this
+                            }
                         })
                         .child(
                             h_flex()
diff --git a/crates/git_ui/src/commit_tooltip.rs b/crates/git_ui/src/commit_tooltip.rs
index 1921de78874..a355d7355b9 100644
--- a/crates/git_ui/src/commit_tooltip.rs
+++ b/crates/git_ui/src/commit_tooltip.rs
@@ -299,11 +299,10 @@ impl Render for CommitTooltip {
                 .child(
                     v_flex()
                         .w(gpui::rems(30.))
-                        .gap_4()
                         .child(
                             h_flex()
-                                .pb_1p5()
-                                .gap_x_2()
+                                .pb_1()
+                                .gap_2()
                                 .overflow_x_hidden()
                                 .flex_wrap()
                                 .child(avatar)
@@ -321,23 +320,24 @@ impl Render for CommitTooltip {
                         .child(
                             div()
                                 .id("inline-blame-commit-message")
-                                .child(message)
+                                .track_scroll(&self.scroll_handle)
+                                .py_1p5()
                                 .max_h(message_max_height)
                                 .overflow_y_scroll()
-                                .track_scroll(&self.scroll_handle),
+                                .child(message),
                         )
                         .child(
                             h_flex()
                                 .text_color(cx.theme().colors().text_muted)
                                 .w_full()
                                 .justify_between()
-                                .pt_1p5()
+                                .pt_1()
                                 .border_t_1()
                                 .border_color(cx.theme().colors().border_variant)
                                 .child(absolute_timestamp)
                                 .child(
                                     h_flex()
-                                        .gap_1p5()
+                                        .gap_1()
                                         .when_some(pull_request, |this, pr| {
                                             this.child(
                                                 Button::new(
@@ -347,9 +347,9 @@ impl Render for CommitTooltip {
                                                 .color(Color::Muted)
                                                 .start_icon(
                                                     Icon::new(IconName::PullRequest)
+                                                        .size(IconSize::Small)
                                                         .color(Color::Muted),
                                                 )
-                                                .style(ButtonStyle::Subtle)
                                                 .on_click(move |_, _, cx| {
                                                     cx.stop_propagation();
                                                     cx.open_url(pr.url.as_str())
@@ -362,10 +362,11 @@ impl Render for CommitTooltip {
                                                 "commit-sha-button",
                                                 short_commit_id.clone(),
                                             )
-                                            .style(ButtonStyle::Subtle)
                                             .color(Color::Muted)
                                             .start_icon(
-                                                Icon::new(IconName::FileGit).color(Color::Muted),
+                                                Icon::new(IconName::FileGit)
+                                                    .size(IconSize::Small)
+                                                    .color(Color::Muted),
                                             )
                                             .on_click(
                                                 move |_, window, cx| {

From 800706d7a8696572fd713ab2c0ff42564639d27b Mon Sep 17 00:00:00 2001
From: Ben Brandt <benjamin.j.brandt@gmail.com>
Date: Thu, 21 May 2026 14:25:34 +0200
Subject: [PATCH 084/105] agent: Add experimental update title tool (#57395)

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Release Notes:

- N/A
---
 assets/settings/default.json                  |   2 +
 crates/agent/src/templates.rs                 |   3 +-
 .../templates/experimental_system_prompt.hbs  |  11 ++
 crates/agent/src/templates/system_prompt.hbs  |  11 ++
 crates/agent/src/tests/mod.rs                 | 150 +++++++++++++++
 crates/agent/src/thread.rs                    | 171 +++++++++++++++++-
 crates/agent/src/tools.rs                     |   3 +
 crates/agent/src/tools/update_title_tool.rs   | 140 ++++++++++++++
 crates/agent_ui/src/agent_panel.rs            |   6 +-
 crates/feature_flags/src/flags.rs             |  12 ++
 .../src/pages/tool_permissions_setup.rs       |   3 +
 11 files changed, 506 insertions(+), 6 deletions(-)
 create mode 100644 crates/agent/src/tools/update_title_tool.rs

diff --git a/assets/settings/default.json b/assets/settings/default.json
index b22e8589183..ca782b5c8e8 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -1133,6 +1133,7 @@
           "spawn_agent": true,
           "terminal": true,
           "update_plan": true,
+          "update_title": true,
           "search_web": true,
         },
       },
@@ -1153,6 +1154,7 @@
           "skill": true,
           "spawn_agent": true,
           "update_plan": true,
+          "update_title": true,
           "search_web": true,
         },
       },
diff --git a/crates/agent/src/templates.rs b/crates/agent/src/templates.rs
index b369b07b81f..51f27eaeddf 100644
--- a/crates/agent/src/templates.rs
+++ b/crates/agent/src/templates.rs
@@ -83,7 +83,7 @@ mod tests {
         let project = prompt_store::ProjectContext::default();
         let template = SystemPromptTemplate {
             project: &project,
-            available_tools: vec!["echo".into(), "update_plan".into()],
+            available_tools: vec!["echo".into(), "update_plan".into(), "update_title".into()],
             model_name: Some("test-model".to_string()),
             date: "2026-01-01".to_string(),
             user_agents_md: None,
@@ -94,6 +94,7 @@ mod tests {
         assert!(rendered.contains("Today's Date: 2026-01-01"));
         assert!(rendered.contains("## Fixing Diagnostics"));
         assert!(rendered.contains("## Planning"));
+        assert!(rendered.contains("## Session Title"));
         assert!(rendered.contains("test-model"));
     }
 
diff --git a/crates/agent/src/templates/experimental_system_prompt.hbs b/crates/agent/src/templates/experimental_system_prompt.hbs
index 2611efc671c..824ee679a2a 100644
--- a/crates/agent/src/templates/experimental_system_prompt.hbs
+++ b/crates/agent/src/templates/experimental_system_prompt.hbs
@@ -52,6 +52,17 @@ Use a plan when:
 - The user asked you to do more than one thing in a single prompt.
 - You discover additional steps while working and intend to complete them before yielding to the user.
 
+{{/if}}
+{{#if (contains available_tools 'update_title') }}
+## Session Title
+
+- Use the `update_title` tool to set the title shown to the user for the current session.
+- You MUST set a title at least once, even for small tasks. Do it early in the conversation, after the first user message, before you start working. There is no title to begin with, so you are responsible for setting one.
+- Update the title again whenever the goal changes materially.
+- Titles are very important to communicate to the user what you are working on. A session should always have a title.
+- Keep titles concise and specific. Prefer a short noun phrase over a full sentence, and do not wrap the title in quotes.
+- Do not mention that you changed the title unless it is directly relevant to the user.
+
 {{/if}}
 ## Searching and Reading
 
diff --git a/crates/agent/src/templates/system_prompt.hbs b/crates/agent/src/templates/system_prompt.hbs
index c7128d9cb6b..54962540757 100644
--- a/crates/agent/src/templates/system_prompt.hbs
+++ b/crates/agent/src/templates/system_prompt.hbs
@@ -74,6 +74,17 @@ Use a plan when:
 - The user asked you to do more than one thing in a single prompt.
 - You discover additional steps while working and intend to complete them before yielding to the user.
 
+{{/if}}
+{{#if (contains available_tools 'update_title') }}
+## Session Title
+
+- Use the `update_title` tool to set the title shown to the user for the current session.
+- You MUST set a title at least once, even for small tasks. Do it early in the conversation, after the first user message, before you start working. There is no title to begin with, so you are responsible for setting one.
+- Update the title again whenever the goal changes materially.
+- Titles are very important to communicate to the user what you are working on. A session should always have a title.
+- Keep titles concise and specific. Prefer a short noun phrase over a full sentence, and do not wrap the title in quotes.
+- Do not mention that you changed the title unless it is directly relevant to the user.
+
 {{/if}}
 ## Searching and Reading
 
diff --git a/crates/agent/src/tests/mod.rs b/crates/agent/src/tests/mod.rs
index 9592d8f7928..eab1c031f0b 100644
--- a/crates/agent/src/tests/mod.rs
+++ b/crates/agent/src/tests/mod.rs
@@ -3807,6 +3807,155 @@ async fn test_update_plan_tool_updates_thread_events(cx: &mut TestAppContext) {
     );
 }
 
+#[gpui::test]
+async fn test_update_title_tool_sets_thread_title(cx: &mut TestAppContext) {
+    let ThreadTest { thread, model, .. } = setup(cx, TestModel::Fake).await;
+    let fake_model = model.as_fake();
+    let summary_model = Arc::new(FakeLanguageModel::default());
+
+    cx.update(|cx| {
+        cx.update_flags(true, vec!["update-title-tool".to_string()]);
+    });
+    thread.update(cx, |thread, cx| {
+        thread.add_tool(UpdateTitleTool::new(cx.weak_entity()));
+        thread.set_summarization_model(Some(summary_model.clone()), cx);
+    });
+
+    let mut events = thread
+        .update(cx, |thread, cx| {
+            thread.send(UserMessageId::new(), ["Explore title tooling"], cx)
+        })
+        .unwrap();
+    cx.run_until_parked();
+
+    let input = json!({
+        "title": "Session title tool"
+    });
+    fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::ToolUse(
+        LanguageModelToolUse {
+            id: "title_1".into(),
+            name: UpdateTitleTool::NAME.into(),
+            raw_input: input.to_string(),
+            input,
+            is_input_complete: true,
+            thought_signature: None,
+        },
+    ));
+    fake_model.end_last_completion_stream();
+    cx.run_until_parked();
+
+    let tool_call = expect_tool_call(&mut events).await;
+    assert_eq!(
+        tool_call,
+        acp::ToolCall::new("title_1", "Update title: Session title tool")
+            .kind(acp::ToolKind::Think)
+            .raw_input(json!({
+                "title": "Session title tool"
+            }))
+            .meta(acp::Meta::from_iter([(
+                "tool_name".into(),
+                "update_title".into()
+            )]))
+    );
+
+    let update = expect_tool_call_update_fields(&mut events).await;
+    assert_eq!(
+        update,
+        acp::ToolCallUpdate::new(
+            "title_1",
+            acp::ToolCallUpdateFields::new().status(acp::ToolCallStatus::InProgress)
+        )
+    );
+
+    let update = expect_tool_call_update_fields(&mut events).await;
+    assert_eq!(
+        update,
+        acp::ToolCallUpdate::new(
+            "title_1",
+            acp::ToolCallUpdateFields::new()
+                .status(acp::ToolCallStatus::Completed)
+                .raw_output("Session title updated")
+        )
+    );
+
+    thread.read_with(cx, |thread, _| {
+        assert_eq!(thread.title(), Some("Session title tool".into()));
+    });
+    assert_eq!(summary_model.pending_completions(), Vec::new());
+}
+
+#[gpui::test]
+async fn test_update_title_availability_suppresses_summary_title_generation(
+    cx: &mut TestAppContext,
+) {
+    let ThreadTest { thread, model, .. } = setup(cx, TestModel::Fake).await;
+    let fake_model = model.as_fake();
+    let summary_model = Arc::new(FakeLanguageModel::default());
+
+    cx.update(|cx| {
+        cx.update_flags(true, vec!["update-title-tool".to_string()]);
+    });
+    thread.update(cx, |thread, cx| {
+        thread.add_tool(UpdateTitleTool::new(cx.weak_entity()));
+        thread.set_summarization_model(Some(summary_model.clone()), cx);
+    });
+
+    let send = thread
+        .update(cx, |thread, cx| {
+            thread.send(UserMessageId::new(), ["Explore title tooling"], cx)
+        })
+        .unwrap();
+    cx.run_until_parked();
+
+    fake_model.send_last_completion_stream_text_chunk("Done");
+    fake_model.end_last_completion_stream();
+    send.collect::<Vec<_>>().await;
+    cx.run_until_parked();
+
+    thread.read_with(cx, |thread, _| {
+        assert_eq!(thread.title(), None);
+    });
+    assert_eq!(summary_model.pending_completions(), Vec::new());
+}
+
+#[gpui::test]
+async fn test_update_title_flag_without_available_tool_falls_back_to_summary_title_generation(
+    cx: &mut TestAppContext,
+) {
+    let ThreadTest { thread, model, .. } = setup(cx, TestModel::Fake).await;
+    let fake_model = model.as_fake();
+    let summary_model = Arc::new(FakeLanguageModel::default());
+
+    cx.update(|cx| {
+        cx.update_flags(true, vec!["update-title-tool".to_string()]);
+    });
+    thread.update(cx, |thread, cx| {
+        thread.set_summarization_model(Some(summary_model.clone()), cx);
+    });
+
+    let send = thread
+        .update(cx, |thread, cx| {
+            thread.send(UserMessageId::new(), ["Explore title tooling"], cx)
+        })
+        .unwrap();
+    cx.run_until_parked();
+
+    fake_model.send_last_completion_stream_text_chunk("Done");
+    fake_model.end_last_completion_stream();
+    cx.run_until_parked();
+
+    assert_eq!(summary_model.pending_completions().len(), 1);
+
+    summary_model.send_last_completion_stream_text_chunk("Fallback title");
+    summary_model.end_last_completion_stream();
+    send.collect::<Vec<_>>().await;
+    cx.run_until_parked();
+
+    thread.read_with(cx, |thread, _| {
+        assert_eq!(thread.title(), Some("Fallback title".into()));
+    });
+}
+
 #[gpui::test]
 async fn test_send_no_retry_on_success(cx: &mut TestAppContext) {
     let ThreadTest { thread, model, .. } = setup(cx, TestModel::Fake).await;
@@ -4320,6 +4469,7 @@ async fn setup(cx: &mut TestAppContext, model: TestModel) -> ThreadTest {
                             StreamingFailingEchoTool::NAME: true,
                             TerminalTool::NAME: true,
                             UpdatePlanTool::NAME: true,
+                            UpdateTitleTool::NAME: true,
                         }
                     }
                 }
diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rs
index 55d7b62b99b..147266b678a 100644
--- a/crates/agent/src/thread.rs
+++ b/crates/agent/src/thread.rs
@@ -4,12 +4,14 @@ use crate::{
     FindPathTool, FindReferencesTool, GetCodeActionsTool, GoToDefinitionTool, GrepTool,
     ListDirectoryTool, MovePathTool, ProjectSnapshot, ReadFileTool, RenameTool, SpawnAgentTool,
     SystemPromptTemplate, Template, Templates, TerminalTool, ToolPermissionDecision,
-    UpdatePlanTool, UserAgentsMd, WebSearchTool, WriteFileTool, decide_permission_from_settings,
+    UpdatePlanTool, UpdateTitleTool, UserAgentsMd, WebSearchTool, WriteFileTool,
+    decide_permission_from_settings,
 };
 use acp_thread::{MentionUri, UserMessageId};
 use action_log::ActionLog;
 use feature_flags::{
     FeatureFlagAppExt as _, LspToolFeatureFlag, RenameToolFeatureFlag, UpdatePlanToolFeatureFlag,
+    UpdateTitleToolFeatureFlag,
 };
 
 use agent_client_protocol::schema as acp;
@@ -1247,10 +1249,11 @@ impl Thread {
             // but still display the saved result if available.
             // We need to send both ToolCall and ToolCallUpdate events because the UI
             // only converts raw_output to displayable content in update_fields, not from_acp.
+            let title = Self::title_for_replayed_tool_use(tool_use);
             stream
                 .0
                 .unbounded_send(Ok(ThreadEvent::ToolCall(
-                    acp::ToolCall::new(tool_use.id.to_string(), tool_use.name.to_string())
+                    acp::ToolCall::new(tool_use.id.to_string(), title.clone())
                         .status(status)
                         .raw_input(tool_use.input.clone()),
                 )))
@@ -1258,6 +1261,9 @@ impl Thread {
             let mut fields = acp::ToolCallUpdateFields::new()
                 .status(status)
                 .raw_output(output);
+            if tool_use.name.as_ref() == UpdateTitleTool::NAME {
+                fields = fields.title(title);
+            }
             if let Some(content) = replay_content {
                 fields = fields.content(content);
             }
@@ -1305,6 +1311,16 @@ impl Thread {
         );
     }
 
+    fn title_for_replayed_tool_use(tool_use: &LanguageModelToolUse) -> String {
+        if tool_use.name.as_ref() == UpdateTitleTool::NAME {
+            let input = serde_json::from_value(tool_use.input.clone())
+                .map_err(|_| serde_json::Value::String(tool_use.raw_input.clone()));
+            UpdateTitleTool::title_for_input(input).to_string()
+        } else {
+            tool_use.name.to_string()
+        }
+    }
+
     fn tool_result_content_for_replay(
         tool_result: &LanguageModelToolResult,
     ) -> Option<Vec<acp::ToolCallContent>> {
@@ -1670,6 +1686,9 @@ impl Thread {
         if cx.has_flag::<UpdatePlanToolFeatureFlag>() {
             self.add_tool(UpdatePlanTool);
         }
+        if cx.has_flag::<UpdateTitleToolFeatureFlag>() {
+            self.add_tool(UpdateTitleTool::new(cx.weak_entity()));
+        }
         self.add_tool(ReadFileTool::new(
             self.project.clone(),
             self.action_log.clone(),
@@ -2183,7 +2202,7 @@ impl Thread {
 
             this.update(cx, |this, cx| {
                 this.flush_pending_message(cx);
-                if this.title.is_none() && this.pending_title_generation.is_none() {
+                if this.title.is_none() {
                     this.generate_title(cx);
                 }
             })?;
@@ -2712,6 +2731,20 @@ impl Thread {
         self.title_generation_failed
     }
 
+    pub fn can_generate_title(&self, cx: &App) -> bool {
+        self.pending_title_generation.is_none()
+            && self.summarization_model.is_some()
+            && !self.update_title_tool_available(cx)
+    }
+
+    fn update_title_tool_available(&self, cx: &App) -> bool {
+        if let Some(running_turn) = self.running_turn.as_ref() {
+            running_turn.tools.contains_key(UpdateTitleTool::NAME)
+        } else {
+            self.enabled_tools(cx).contains_key(UpdateTitleTool::NAME)
+        }
+    }
+
     pub fn summary(&mut self, cx: &mut Context<Self>) -> Shared<Task<Option<SharedString>>> {
         if let Some(summary) = self.summary.as_ref() {
             return Task::ready(Some(summary.clone())).shared();
@@ -2773,6 +2806,10 @@ impl Thread {
     }
 
     pub fn generate_title(&mut self, cx: &mut Context<Self>) {
+        if !self.can_generate_title(cx) {
+            return;
+        }
+
         self.title_generation_failed = false;
         let Some(model) = self.summarization_model.clone() else {
             return;
@@ -4626,6 +4663,134 @@ mod tests {
         assert!(tool_use_ids_with_image_content.contains(&missing_tool_use_id.to_string()));
     }
 
+    #[gpui::test]
+    async fn test_update_title_tool_replay_does_not_reenter_thread(cx: &mut TestAppContext) {
+        let (thread, _event_stream) = setup_thread_for_test(cx).await;
+
+        let tool_use_id = LanguageModelToolUseId::from("title_tool_id");
+        let mut replay_events = cx.update(|cx| {
+            thread.update(cx, |thread, cx| {
+                thread.add_tool(UpdateTitleTool::new(cx.weak_entity()));
+                push_completed_update_title_tool_call(thread, tool_use_id.clone());
+
+                thread.replay(cx)
+            })
+        });
+
+        let mut saw_tool_call_title = false;
+        let mut saw_replayed_title_update = false;
+        let mut saw_completed_update = false;
+        while let Some(event) = replay_events.next().await {
+            let event = event.unwrap();
+            match event {
+                ThreadEvent::ToolCall(tool_call)
+                    if tool_call.tool_call_id.to_string() == tool_use_id.to_string()
+                        && tool_call.title == "Update title: Replayed title" =>
+                {
+                    saw_tool_call_title = true;
+                }
+                ThreadEvent::ToolCallUpdate(acp_thread::ToolCallUpdate::UpdateFields(update))
+                    if update.tool_call_id.to_string() == tool_use_id.to_string() =>
+                {
+                    if update.fields.title == Some("Update title: Replayed title".to_string()) {
+                        saw_replayed_title_update = true;
+                    }
+                    if update.fields.status == Some(acp::ToolCallStatus::Completed) {
+                        saw_completed_update = true;
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        assert!(saw_tool_call_title);
+        assert!(saw_replayed_title_update);
+        assert!(saw_completed_update);
+        thread.read_with(cx, |thread, _cx| {
+            assert_eq!(thread.title(), None);
+        });
+    }
+
+    #[gpui::test]
+    async fn test_update_title_tool_replay_title_when_tool_not_registered(cx: &mut TestAppContext) {
+        let (thread, _event_stream) = setup_thread_for_test(cx).await;
+
+        let tool_use_id = LanguageModelToolUseId::from("title_tool_id");
+        let mut replay_events = cx.update(|cx| {
+            thread.update(cx, |thread, cx| {
+                push_completed_update_title_tool_call(thread, tool_use_id.clone());
+                thread.replay(cx)
+            })
+        });
+
+        let mut saw_tool_call_title = false;
+        let mut saw_replayed_title_update = false;
+        let mut saw_completed_update = false;
+        while let Some(event) = replay_events.next().await {
+            let event = event.unwrap();
+            match event {
+                ThreadEvent::ToolCall(tool_call)
+                    if tool_call.tool_call_id.to_string() == tool_use_id.to_string()
+                        && tool_call.title == "Update title: Replayed title" =>
+                {
+                    saw_tool_call_title = true;
+                }
+                ThreadEvent::ToolCallUpdate(acp_thread::ToolCallUpdate::UpdateFields(update))
+                    if update.tool_call_id.to_string() == tool_use_id.to_string() =>
+                {
+                    if update.fields.title == Some("Update title: Replayed title".to_string()) {
+                        saw_replayed_title_update = true;
+                    }
+                    if update.fields.status == Some(acp::ToolCallStatus::Completed) {
+                        saw_completed_update = true;
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        assert!(saw_tool_call_title);
+        assert!(saw_replayed_title_update);
+        assert!(saw_completed_update);
+        thread.read_with(cx, |thread, _cx| {
+            assert_eq!(thread.title(), None);
+        });
+    }
+
+    fn push_completed_update_title_tool_call(
+        thread: &mut Thread,
+        tool_use_id: LanguageModelToolUseId,
+    ) {
+        let tool_use = LanguageModelToolUse {
+            id: tool_use_id.clone(),
+            name: UpdateTitleTool::NAME.into(),
+            raw_input: json!({ "title": "Replayed title" }).to_string(),
+            input: json!({ "title": "Replayed title" }),
+            is_input_complete: true,
+            thought_signature: None,
+        };
+
+        let mut tool_results = IndexMap::default();
+        tool_results.insert(
+            tool_use_id.clone(),
+            LanguageModelToolResult {
+                tool_use_id,
+                tool_name: UpdateTitleTool::NAME.into(),
+                is_error: false,
+                content: vec![LanguageModelToolResultContent::Text(
+                    "Session title updated".into(),
+                )],
+                output: Some(json!("Session title updated")),
+            },
+        );
+
+        thread.messages.push(Message::Agent(AgentMessage {
+            content: vec![AgentMessageContent::ToolUse(tool_use)],
+            tool_results,
+            reasoning_details: None,
+        }));
+    }
+
     #[gpui::test]
     async fn test_set_model_propagates_to_subagents(cx: &mut TestAppContext) {
         let (parent, _event_stream) = setup_thread_for_test(cx).await;
diff --git a/crates/agent/src/tools.rs b/crates/agent/src/tools.rs
index 5440fe149f8..187ce7f6578 100644
--- a/crates/agent/src/tools.rs
+++ b/crates/agent/src/tools.rs
@@ -24,6 +24,7 @@ mod symbol_locator;
 mod terminal_tool;
 mod tool_permissions;
 mod update_plan_tool;
+mod update_title_tool;
 mod web_search_tool;
 mod write_file_tool;
 
@@ -80,6 +81,7 @@ pub use symbol_locator::*;
 pub use terminal_tool::*;
 pub use tool_permissions::*;
 pub use update_plan_tool::*;
+pub use update_title_tool::*;
 pub use web_search_tool::*;
 pub use write_file_tool::*;
 
@@ -172,6 +174,7 @@ tools! {
     SpawnAgentTool,
     TerminalTool,
     UpdatePlanTool,
+    UpdateTitleTool,
     WebSearchTool,
     WriteFileTool,
 }
diff --git a/crates/agent/src/tools/update_title_tool.rs b/crates/agent/src/tools/update_title_tool.rs
new file mode 100644
index 00000000000..b86b82f9ac0
--- /dev/null
+++ b/crates/agent/src/tools/update_title_tool.rs
@@ -0,0 +1,140 @@
+use crate::{AgentTool, Thread, ToolCallEventStream, ToolInput};
+use agent_client_protocol::schema as acp;
+use gpui::{App, SharedString, Task, WeakEntity};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+const MAX_TITLE_LEN: usize = 200;
+
+/// Updates the current session title.
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
+pub struct UpdateTitleToolInput {
+    /// A concise, human-readable title for the current session.
+    pub title: String,
+}
+
+pub struct UpdateTitleTool {
+    thread: WeakEntity<Thread>,
+}
+
+impl UpdateTitleTool {
+    pub fn new(thread: WeakEntity<Thread>) -> Self {
+        Self { thread }
+    }
+
+    pub(crate) fn title_for_input(
+        input: Result<UpdateTitleToolInput, serde_json::Value>,
+    ) -> SharedString {
+        let Ok(input) = input else {
+            return "Update title".into();
+        };
+        let Ok(title) = normalize_title(&input.title) else {
+            return "Update title".into();
+        };
+        format!("Update title: {title}").into()
+    }
+}
+
+impl AgentTool for UpdateTitleTool {
+    type Input = UpdateTitleToolInput;
+    type Output = String;
+
+    const NAME: &'static str = "update_title";
+
+    fn kind() -> acp::ToolKind {
+        acp::ToolKind::Think
+    }
+
+    fn initial_title(
+        &self,
+        input: Result<Self::Input, serde_json::Value>,
+        _cx: &mut App,
+    ) -> SharedString {
+        Self::title_for_input(input)
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: ToolInput<Self::Input>,
+        _event_stream: ToolCallEventStream,
+        cx: &mut App,
+    ) -> Task<Result<Self::Output, Self::Output>> {
+        let thread = self.thread.clone();
+        cx.spawn(async move |cx| {
+            let input = input.recv().await.map_err(|error| error.to_string())?;
+            let title = normalize_title(&input.title)?;
+
+            thread
+                .update(cx, |thread, cx| {
+                    thread.set_title(title.into(), cx);
+                })
+                .map_err(|error| error.to_string())?;
+
+            Ok("Session title updated".to_string())
+        })
+    }
+
+    fn replay(
+        &self,
+        input: Self::Input,
+        _output: Self::Output,
+        event_stream: ToolCallEventStream,
+        cx: &mut App,
+    ) -> anyhow::Result<()> {
+        let title = self.initial_title(Ok(input), cx).to_string();
+        event_stream.update_fields(acp::ToolCallUpdateFields::new().title(title));
+        Ok(())
+    }
+}
+
+fn normalize_title(title: &str) -> Result<String, String> {
+    let title = title.lines().next().unwrap_or("").trim();
+    if title.is_empty() {
+        return Err("Title cannot be empty".to_string());
+    }
+    Ok(util::truncate_and_trailoff(title, MAX_TITLE_LEN))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use gpui::TestAppContext;
+
+    #[test]
+    fn test_normalize_title() {
+        assert_eq!(
+            normalize_title("  Title from model\nignored").unwrap(),
+            "Title from model"
+        );
+        assert!(normalize_title(" \nignored").is_err());
+    }
+
+    #[gpui::test]
+    async fn test_initial_title(cx: &mut TestAppContext) {
+        let tool = UpdateTitleTool::new(WeakEntity::new_invalid());
+
+        let title = cx.update(|cx| {
+            tool.initial_title(
+                Ok(UpdateTitleToolInput {
+                    title: "Investigate title updates".to_string(),
+                }),
+                cx,
+            )
+        });
+        assert_eq!(
+            title,
+            SharedString::from("Update title: Investigate title updates")
+        );
+
+        let title = cx.update(|cx| {
+            tool.initial_title(
+                Ok(UpdateTitleToolInput {
+                    title: " ".to_string(),
+                }),
+                cx,
+            )
+        });
+        assert_eq!(title, SharedString::from("Update title"));
+    }
+}
diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs
index f868ff9360e..c99109a7d24 100644
--- a/crates/agent_ui/src/agent_panel.rs
+++ b/crates/agent_ui/src/agent_panel.rs
@@ -4716,7 +4716,7 @@ impl AgentPanel {
         conversation_view.update(cx, |conversation_view, cx| {
             if let Some(thread) = conversation_view.as_native_thread(cx) {
                 thread.update(cx, |thread, cx| {
-                    if !thread.is_generating_title() {
+                    if thread.can_generate_title(cx) {
                         thread.generate_title(cx);
                         cx.notify();
                     }
@@ -4752,7 +4752,9 @@ impl AgentPanel {
             conversation_view.as_ref().is_some_and(|conversation_view| {
                 let conversation_view = conversation_view.read(cx);
                 conversation_view.has_user_submitted_prompt(cx)
-                    && conversation_view.as_native_thread(cx).is_some()
+                    && conversation_view
+                        .as_native_thread(cx)
+                        .is_some_and(|thread| thread.read(cx).can_generate_title(cx))
             });
 
         let has_auth_methods = match &self.base_view {
diff --git a/crates/feature_flags/src/flags.rs b/crates/feature_flags/src/flags.rs
index 9f3c54394b9..1c24ac71f7d 100644
--- a/crates/feature_flags/src/flags.rs
+++ b/crates/feature_flags/src/flags.rs
@@ -59,6 +59,18 @@ impl FeatureFlag for UpdatePlanToolFeatureFlag {
 }
 register_feature_flag!(UpdatePlanToolFeatureFlag);
 
+pub struct UpdateTitleToolFeatureFlag;
+
+impl FeatureFlag for UpdateTitleToolFeatureFlag {
+    const NAME: &'static str = "update-title-tool";
+    type Value = PresenceFlag;
+
+    fn enabled_for_staff() -> bool {
+        false
+    }
+}
+register_feature_flag!(UpdateTitleToolFeatureFlag);
+
 pub struct LspToolFeatureFlag;
 
 impl FeatureFlag for LspToolFeatureFlag {
diff --git a/crates/settings_ui/src/pages/tool_permissions_setup.rs b/crates/settings_ui/src/pages/tool_permissions_setup.rs
index 0484181fb61..3122e63d2b6 100644
--- a/crates/settings_ui/src/pages/tool_permissions_setup.rs
+++ b/crates/settings_ui/src/pages/tool_permissions_setup.rs
@@ -1423,6 +1423,9 @@ mod tests {
             // update_plan updates UI-visible planning state but does not use
             // tool permission rules.
             "update_plan",
+            // update_title updates UI-visible session metadata but
+            // does not use tool permission rules.
+            "update_title",
         ];
 
         let tool_info_ids: Vec<&str> = TOOLS.iter().map(|t| t.id).collect();

From e024200c67e051822c455cf4bf27694a067fe55d Mon Sep 17 00:00:00 2001
From: Ben Brandt <benjamin.j.brandt@gmail.com>
Date: Thu, 21 May 2026 14:37:12 +0200
Subject: [PATCH 085/105] agent_ui: Add keybindable action for terminal threads
 (#57399)

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Release Notes:

- Add `agent::NewTerminalThread` for defining custom shortcuts to launch
an Agent Panel terminal thread.
---
 crates/agent_ui/src/agent_panel.rs | 26 +++++++++++++--
 crates/agent_ui/src/agent_ui.rs    | 10 ++++++
 crates/sidebar/src/sidebar.rs      | 52 ++++++++++++++++++++++++++----
 3 files changed, 79 insertions(+), 9 deletions(-)

diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs
index c99109a7d24..e52d0431bc2 100644
--- a/crates/agent_ui/src/agent_panel.rs
+++ b/crates/agent_ui/src/agent_panel.rs
@@ -38,9 +38,9 @@ use crate::terminal_thread_metadata_store::{TerminalThreadMetadata, TerminalThre
 use crate::thread_metadata_store::{ThreadId, ThreadMetadataStore, ThreadMetadataStoreEvent};
 use crate::{
     AddContextServer, AgentDiffPane, ConversationView, CopyThreadToClipboard, Follow,
-    LoadThreadFromClipboard, NewThread, OpenActiveThreadAsMarkdown, OpenAgentDiff,
-    ResetTrialEndUpsell, ResetTrialUpsell, ShowAllSidebarThreadMetadata, ShowThreadMetadata,
-    ToggleNewThreadMenu, ToggleOptionsMenu,
+    LoadThreadFromClipboard, NewTerminalThread, NewThread, OpenActiveThreadAsMarkdown,
+    OpenAgentDiff, ResetTrialEndUpsell, ResetTrialUpsell, ShowAllSidebarThreadMetadata,
+    ShowThreadMetadata, ToggleNewThreadMenu, ToggleOptionsMenu,
     agent_configuration::{AgentConfiguration, AssistantConfigurationEvent},
     conversation_view::{AcpThreadViewEvent, ThreadView},
     ui::{AgentNotification, AgentNotificationEvent, EndTrialUpsell},
@@ -261,6 +261,19 @@ pub fn init(cx: &mut App) {
                         workspace.focus_panel::<AgentPanel>(window, cx);
                     }
                 })
+                .register_action(|workspace, _: &NewTerminalThread, window, cx| {
+                    if let Some(panel) = workspace.panel::<AgentPanel>(cx) {
+                        panel.update(cx, |panel, cx| {
+                            panel.new_terminal(
+                                Some(workspace),
+                                AgentThreadSource::AgentPanel,
+                                window,
+                                cx,
+                            )
+                        });
+                        workspace.focus_panel::<AgentPanel>(window, cx);
+                    }
+                })
                 .register_action(
                     |workspace, action: &NewNativeAgentThreadFromSummary, window, cx| {
                         if let Some(panel) = workspace.panel::<AgentPanel>(cx) {
@@ -4989,6 +5002,9 @@ impl AgentPanel {
                             menu.item(
                                 ContextMenuEntry::new("Terminal")
                                     .when(showing_terminal, |this| this.action(Box::new(NewThread)))
+                                    .when(!showing_terminal, |this| {
+                                        this.action(Box::new(NewTerminalThread))
+                                    })
                                     .icon(IconName::Terminal)
                                     .icon_color(Color::Muted)
                                     .handler({
@@ -5648,6 +5664,10 @@ impl Render for AgentPanel {
             .on_action(cx.listener(|this, action: &NewThread, window, cx| {
                 this.new_thread(action, window, cx);
             }))
+            .on_action(cx.listener(|this, _: &NewTerminalThread, window, cx| {
+                cx.stop_propagation();
+                this.new_terminal(None, AgentThreadSource::AgentPanel, window, cx);
+            }))
             .on_action(cx.listener(|this, _: &OpenSettings, window, cx| {
                 this.open_configuration(window, cx);
             }))
diff --git a/crates/agent_ui/src/agent_ui.rs b/crates/agent_ui/src/agent_ui.rs
index bb3fb26ac62..c9063378d89 100644
--- a/crates/agent_ui/src/agent_ui.rs
+++ b/crates/agent_ui/src/agent_ui.rs
@@ -244,6 +244,8 @@ actions!(
         ScrollOutputToNextMessage,
         /// Import agent threads from other Zed release channels (e.g. Preview, Nightly).
         ImportThreadsFromOtherChannels,
+        /// Starts a new terminal thread.
+        NewTerminalThread,
     ]
 );
 
@@ -850,6 +852,10 @@ mod tests {
                 !filter.is_hidden(&NewThread),
                 "NewThread should be visible by default"
             );
+            assert!(
+                !filter.is_hidden(&NewTerminalThread),
+                "NewTerminalThread should be visible by default"
+            );
         });
 
         // Disable agent
@@ -869,6 +875,10 @@ mod tests {
                 filter.is_hidden(&NewThread),
                 "NewThread should be hidden when agent is disabled"
             );
+            assert!(
+                filter.is_hidden(&NewTerminalThread),
+                "NewTerminalThread should be hidden when agent is disabled"
+            );
         });
 
         // Test EditPredictionProvider
diff --git a/crates/sidebar/src/sidebar.rs b/crates/sidebar/src/sidebar.rs
index 1dfec54ebaa..199c453d092 100644
--- a/crates/sidebar/src/sidebar.rs
+++ b/crates/sidebar/src/sidebar.rs
@@ -17,8 +17,8 @@ use agent_ui::threads_archive_view::{
 };
 use agent_ui::{
     AcpThreadImportOnboarding, Agent, AgentPanel, AgentPanelEvent, AgentThreadSource,
-    ArchiveSelectedThread, CrossChannelImportOnboarding, DEFAULT_THREAD_TITLE, NewThread,
-    TerminalId, ThreadId, ThreadImportModal, channels_with_threads,
+    ArchiveSelectedThread, CrossChannelImportOnboarding, DEFAULT_THREAD_TITLE, NewTerminalThread,
+    NewThread, TerminalId, ThreadId, ThreadImportModal, channels_with_threads,
     import_threads_from_other_channels,
 };
 use chrono::{DateTime, Utc};
@@ -107,6 +107,12 @@ enum SerializedSidebarView {
     History,
 }
 
+#[derive(Clone, Copy)]
+enum NewEntryTarget {
+    LastCreatedKind,
+    Terminal,
+}
+
 #[derive(Default, Serialize, Deserialize)]
 struct SerializedSidebar {
     #[serde(default)]
@@ -1130,6 +1136,7 @@ impl Sidebar {
     fn open_workspace_and_create_entry(
         &mut self,
         project_group_key: &ProjectGroupKey,
+        target: NewEntryTarget,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
@@ -1158,8 +1165,9 @@ impl Sidebar {
 
         cx.spawn_in(window, async move |this, cx| {
             let workspace = task.await?;
-            this.update_in(cx, |this, window, cx| {
-                this.create_new_entry(&workspace, window, cx);
+            this.update_in(cx, |this, window, cx| match target {
+                NewEntryTarget::LastCreatedKind => this.create_new_entry(&workspace, window, cx),
+                NewEntryTarget::Terminal => this.create_new_terminal(&workspace, window, cx),
             })?;
             anyhow::Ok(())
         })
@@ -2092,7 +2100,12 @@ impl Sidebar {
                                 if let Some(workspace) = this.workspace_for_group(&key, cx) {
                                     this.create_new_entry(&workspace, window, cx);
                                 } else {
-                                    this.open_workspace_and_create_entry(&key, window, cx);
+                                    this.open_workspace_and_create_entry(
+                                        &key,
+                                        NewEntryTarget::LastCreatedKind,
+                                        window,
+                                        cx,
+                                    );
                                 }
                             },
                         ))
@@ -5578,13 +5591,39 @@ impl Sidebar {
             if let Some(workspace) = self.workspace_for_group(&key, cx) {
                 self.create_new_entry(&workspace, window, cx);
             } else {
-                self.open_workspace_and_create_entry(&key, window, cx);
+                self.open_workspace_and_create_entry(
+                    &key,
+                    NewEntryTarget::LastCreatedKind,
+                    window,
+                    cx,
+                );
             }
         } else if let Some(workspace) = self.active_workspace(cx) {
             self.create_new_entry(&workspace, window, cx);
         }
     }
 
+    fn new_terminal_thread(
+        &mut self,
+        _: &NewTerminalThread,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        cx.stop_propagation();
+
+        if let Some(key) = self.selected_group_key() {
+            self.set_group_expanded(&key, true, cx);
+            self.selection = None;
+            if let Some(workspace) = self.workspace_for_group(&key, cx) {
+                self.create_new_terminal(&workspace, window, cx);
+            } else {
+                self.open_workspace_and_create_entry(&key, NewEntryTarget::Terminal, window, cx);
+            }
+        } else if let Some(workspace) = self.active_workspace(cx) {
+            self.create_new_terminal(&workspace, window, cx);
+        }
+    }
+
     /// Closed linked-worktree drafts need an open workspace so archive root
     /// planning can inspect repositories before deleting the worktree.
     fn open_workspace_and_remove_draft(
@@ -6794,6 +6833,7 @@ impl Render for Sidebar {
             .on_action(cx.listener(Self::cancel))
             .on_action(cx.listener(Self::archive_selected_thread))
             .on_action(cx.listener(Self::new_thread_in_group))
+            .on_action(cx.listener(Self::new_terminal_thread))
             .on_action(cx.listener(Self::toggle_archive))
             .on_action(cx.listener(Self::focus_sidebar_filter))
             .on_action(cx.listener(Self::on_toggle_thread_switcher))

From 78b5c0e774d671d6537e46cbe7438b0574a1010e Mon Sep 17 00:00:00 2001
From: Ben Kunkle <ben@zed.dev>
Date: Thu, 21 May 2026 09:21:00 -0400
Subject: [PATCH 086/105] Fix bookkeeping error in tracking of language server
 IDs when dropping single-file worktree (#57298)

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Closes #ISSUE

Release Notes:

- N/A or Added/Fixed/Improved ...
---
 crates/project/src/lsp_store.rs               | 16 +++-
 crates/project/tests/integration/lsp_store.rs | 90 ++++++++++++++++++-
 2 files changed, 102 insertions(+), 4 deletions(-)

diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index d288f0021fc..4561ace3b3d 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -3594,8 +3594,10 @@ impl LocalLspStore {
             }
         }
         servers_to_remove.retain(|server_id| !servers_to_preserve.contains(server_id));
-        self.language_server_ids
-            .retain(|_, state| !servers_to_remove.contains(&state.id));
+        self.language_server_ids.retain(|seed, state| {
+            seed.worktree_id != id_to_remove && !servers_to_remove.contains(&state.id)
+        });
+        self.lsp_tree.instances.remove(&id_to_remove);
         for server_id_to_remove in &servers_to_remove {
             self.language_server_watched_paths
                 .remove(server_id_to_remove);
@@ -10101,6 +10103,16 @@ impl LspStore {
             .map(|(key, value)| (*key, value))
     }
 
+    #[cfg(feature = "test-support")]
+    pub fn has_language_server_seed_for_worktree(&self, worktree_id: WorktreeId) -> bool {
+        self.as_local().is_some_and(|local| {
+            local
+                .language_server_ids
+                .keys()
+                .any(|seed| seed.worktree_id == worktree_id)
+        })
+    }
+
     pub(super) fn did_rename_entry(
         &self,
         worktree_id: WorktreeId,
diff --git a/crates/project/tests/integration/lsp_store.rs b/crates/project/tests/integration/lsp_store.rs
index 7d266ff1365..100042f5d99 100644
--- a/crates/project/tests/integration/lsp_store.rs
+++ b/crates/project/tests/integration/lsp_store.rs
@@ -1,8 +1,94 @@
 use std::path::Path;
 
-use language::{CodeLabel, HighlightId};
+use fs::FakeFs;
+use futures::StreamExt;
+use gpui::TestAppContext;
+use language::{CodeLabel, FakeLspAdapter, HighlightId, rust_lang};
+use lsp::Uri;
+use project::{Project, lsp_store::*};
+use serde_json::json;
+use util::path;
 
-use project::lsp_store::*;
+use crate::init_test;
+
+#[gpui::test]
+async fn test_removing_invisible_worktree_cleans_reused_lsp_bookkeeping(cx: &mut TestAppContext) {
+    init_test(cx);
+    cx.executor().allow_parking();
+
+    let fs = FakeFs::new(cx.executor());
+    fs.insert_tree(path!("/the-root"), json!({ "main.rs": "fn main() {}" }))
+        .await;
+    fs.insert_tree(
+        path!("/the-registry"),
+        json!({ "dep": { "src": { "dep.rs": "pub fn dep() {}" } } }),
+    )
+    .await;
+
+    let project = Project::test(fs, [path!("/the-root").as_ref()], cx).await;
+    let language_registry = project.read_with(cx, |project, _| project.languages().clone());
+    language_registry.add(rust_lang());
+    let mut fake_servers = language_registry.register_fake_lsp("Rust", FakeLspAdapter::default());
+
+    let (_visible_buffer, _visible_handle) = project
+        .update(cx, |project, cx| {
+            project.open_local_buffer_with_lsp(path!("/the-root/main.rs"), cx)
+        })
+        .await
+        .unwrap();
+    fake_servers.next().await.unwrap();
+    cx.run_until_parked();
+
+    let server_id = project.read_with(cx, |project, cx| {
+        project
+            .lsp_store()
+            .read(cx)
+            .language_server_statuses()
+            .next()
+            .unwrap()
+            .0
+    });
+    let external_buffer = project
+        .update(cx, |project, cx| {
+            project.open_local_buffer_via_lsp(
+                Uri::from_file_path(path!("/the-registry/dep/src/dep.rs")).unwrap(),
+                server_id,
+                cx,
+            )
+        })
+        .await
+        .unwrap();
+    cx.run_until_parked();
+
+    let invisible_worktree_id =
+        external_buffer.read_with(cx, |buffer, cx| buffer.file().unwrap().worktree_id(cx));
+    project.read_with(cx, |project, cx| {
+        let worktree = project.worktree_for_id(invisible_worktree_id, cx).unwrap();
+        assert!(!worktree.read(cx).is_visible());
+        assert!(
+            project
+                .lsp_store()
+                .read(cx)
+                .has_language_server_seed_for_worktree(invisible_worktree_id)
+        );
+    });
+
+    project.update(cx, |project, cx| {
+        project.remove_worktree(invisible_worktree_id, cx);
+    });
+    cx.run_until_parked();
+
+    project.read_with(cx, |project, cx| {
+        let lsp_store = project.lsp_store();
+        let lsp_store = lsp_store.read(cx);
+        assert!(
+            lsp_store
+                .language_server_statuses()
+                .any(|(status_server_id, _)| status_server_id == server_id)
+        );
+        assert!(!lsp_store.has_language_server_seed_for_worktree(invisible_worktree_id));
+    });
+}
 
 #[test]
 fn test_glob_literal_prefix() {

From 8d28ca5c01a092a9249ed6bef8af8d4eeaf637ba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=20Houl=C3=A9?=
 <13155277+tomhoule@users.noreply.github.com>
Date: Thu, 21 May 2026 17:21:19 +0200
Subject: [PATCH 087/105] client: Reconnect cloud websocket after it
 disconnects (#57078)

The cloud websocket was established once during sign-in and never
re-established. On any server restart or transient network drop the
connection task exited. yawc itself does not reconnect.

This wraps `connect_to_cloud` in a long-lived task that re-establishes
the websocket with exponential backoff and jitter, reusing
`INITIAL_RECONNECTION_DELAY` and `MAX_RECONNECTION_DELAY` so the
behavior matches the Collab reconnect loop in the same module.

Part of CLO-713.

Release Notes:

- N/A
---
 crates/client/src/client.rs | 62 ++++++++++++++++++++++++++++---------
 1 file changed, 47 insertions(+), 15 deletions(-)

diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs
index d8973166810..093eb894483 100644
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -334,6 +334,7 @@ struct ClientState {
     credentials: Option<Credentials>,
     status: (watch::Sender<Status>, watch::Receiver<Status>),
     _reconnect_task: Option<Task<()>>,
+    _cloud_connection_task: Option<Task<()>>,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -435,6 +436,7 @@ impl Default for ClientState {
             credentials: None,
             status: watch::channel_with(Status::SignedOut),
             _reconnect_task: None,
+            _cloud_connection_task: None,
         }
     }
 }
@@ -607,6 +609,7 @@ impl Client {
     pub fn teardown(&self) {
         let mut state = self.state.write();
         state._reconnect_task.take();
+        state._cloud_connection_task.take();
         self.handler_set.lock().clear();
         self.peer.teardown();
     }
@@ -724,6 +727,7 @@ impl Client {
             Status::SignedOut | Status::UpgradeRequired => {
                 self.telemetry.set_authenticated_user_info(None, false);
                 state._reconnect_task.take();
+                state._cloud_connection_task.take();
             }
             _ => {}
         }
@@ -957,28 +961,56 @@ impl Client {
         }
     }
 
-    /// Establishes a WebSocket connection with Cloud for receiving updates from the server.
-    async fn connect_to_cloud(self: &Arc<Self>, cx: &AsyncApp) -> Result<()> {
+    /// Maintains a WebSocket connection with Cloud for receiving updates from the server.
+    ///
+    /// The connection is re-established with exponential backoff if it drops or fails to
+    /// establish.
+    fn connect_to_cloud(self: &Arc<Self>, cx: &AsyncApp) {
+        let this = self.clone();
+        let task = cx.spawn(async move |cx| {
+            #[cfg(any(test, feature = "test-support"))]
+            let mut rng = StdRng::seed_from_u64(0);
+            #[cfg(not(any(test, feature = "test-support")))]
+            let mut rng = StdRng::from_os_rng();
+
+            let mut delay = INITIAL_RECONNECTION_DELAY;
+            loop {
+                match Self::run_cloud_connection(&this, cx).await {
+                    Ok(()) => {
+                        log::info!("cloud websocket disconnected, will reconnect");
+                        delay = INITIAL_RECONNECTION_DELAY;
+                    }
+                    Err(err) => {
+                        log::warn!(
+                            "cloud websocket connect failed: {err:#}; retrying in {delay:?}"
+                        );
+                    }
+                }
+
+                let jitter = Duration::from_millis(rng.random_range(0..delay.as_millis() as u64));
+                cx.background_executor().timer(delay + jitter).await;
+                delay = cmp::min(delay * 2, MAX_RECONNECTION_DELAY);
+            }
+        });
+        self.state.write()._cloud_connection_task = Some(task);
+    }
+
+    /// Runs a single attempt of the cloud websocket connection, returning once the connection
+    /// closes (cleanly or otherwise) or fails to establish.
+    async fn run_cloud_connection(self: &Arc<Self>, cx: &mut AsyncApp) -> Result<()> {
         let connect_task = cx.update({
             let cloud_client = self.cloud_client.clone();
             move |cx| cloud_client.connect(cx)
         })?;
         let connection = connect_task.await?;
 
-        let (mut messages, task) = cx.update(|cx| connection.spawn(cx));
-        task.detach();
+        let (mut messages, _cloud_io_task) = cx.update(|cx| connection.spawn(cx));
 
-        cx.spawn({
-            let this = self.clone();
-            async move |cx| {
-                while let Some(message) = messages.next().await {
-                    if let Some(message) = message.log_err() {
-                        this.handle_message_to_client(message, cx);
-                    }
-                }
+        while let Some(message) = messages.next().await {
+            if let Some(message) = message.log_err() {
+                self.handle_message_to_client(message, cx);
             }
-        })
-        .detach();
+        }
 
         Ok(())
     }
@@ -1009,7 +1041,7 @@ impl Client {
 
         let credentials = self.sign_in(try_provider, cx).await?;
 
-        self.connect_to_cloud(cx).await.log_err();
+        self.connect_to_cloud(cx);
 
         cx.update(move |cx| {
             cx.spawn({

From 560f784776b4662577ac6b393ccf47ffbba0cd08 Mon Sep 17 00:00:00 2001
From: Ben Kunkle <ben@zed.dev>
Date: Thu, 21 May 2026 11:23:20 -0400
Subject: [PATCH 088/105] ep: Increase example capture rate (#57208)

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Closes #ISSUE

Release Notes:

- N/A or Added/Fixed/Improved ...
---
 crates/buffer_diff/src/buffer_diff.rs         |   4 +
 crates/edit_prediction/src/capture_example.rs | 288 ++++++++++++++----
 crates/edit_prediction/src/edit_prediction.rs | 145 ++++++++-
 .../src/edit_prediction_tests.rs              |   3 +
 crates/edit_prediction/src/example_spec.rs    |  98 ++++++
 crates/edit_prediction/src/zeta.rs            |  46 ++-
 .../edit_prediction_cli/src/format_prompt.rs  |   6 +
 .../edit_prediction_cli/src/pull_examples.rs  |   3 +
 crates/edit_prediction_cli/src/repair.rs      |   3 +
 .../edit_prediction_cli/src/split_commit.rs   |   6 +
 crates/edit_prediction_cli/src/synthesize.rs  |   3 +
 .../src/edit_prediction_button.rs             |   9 +-
 .../src/edit_prediction_ui.rs                 |  76 +----
 crates/language/src/language_settings.rs      |   2 -
 crates/settings_content/src/language.rs       |   4 +-
 15 files changed, 530 insertions(+), 166 deletions(-)

diff --git a/crates/buffer_diff/src/buffer_diff.rs b/crates/buffer_diff/src/buffer_diff.rs
index 56c3fe9f51b..ccf8dfd3412 100644
--- a/crates/buffer_diff/src/buffer_diff.rs
+++ b/crates/buffer_diff/src/buffer_diff.rs
@@ -267,6 +267,10 @@ impl BufferDiffSnapshot {
             .then(|| self.inner.base_text.text())
     }
 
+    pub fn base_text_exists(&self) -> bool {
+        self.inner.base_text_exists
+    }
+
     pub fn secondary_diff(&self) -> Option<&BufferDiffSnapshot> {
         self.secondary_diff.as_deref()
     }
diff --git a/crates/edit_prediction/src/capture_example.rs b/crates/edit_prediction/src/capture_example.rs
index 9463456132c..c01cd935786 100644
--- a/crates/edit_prediction/src/capture_example.rs
+++ b/crates/edit_prediction/src/capture_example.rs
@@ -1,18 +1,24 @@
-use crate::{StoredEvent, example_spec::ExampleSpec};
+use crate::{
+    StoredEvent,
+    example_spec::{ExampleSpec, RecentFile},
+};
 use anyhow::Result;
-use buffer_diff::BufferDiffSnapshot;
+use buffer_diff::{BufferDiff, BufferDiffSnapshot};
 use collections::HashMap;
 use gpui::{App, Entity, Task};
 use language::Buffer;
-use project::{Project, WorktreeId};
+use project::Project;
 use std::{collections::hash_map, fmt::Write as _, ops::Range, path::Path, sync::Arc};
-use text::{BufferSnapshot as TextBufferSnapshot, Point};
+use text::Point;
 
 pub fn capture_example(
     project: Entity<Project>,
     buffer: Entity<Buffer>,
     cursor_anchor: language::Anchor,
-    mut events: Vec<StoredEvent>,
+    events: Vec<StoredEvent>,
+    recently_opened_files: Vec<RecentFile>,
+    recently_viewed_files: Vec<RecentFile>,
+    uncommitted_diffs_by_path: HashMap<Arc<Path>, Entity<BufferDiff>>,
     populate_expected_patch: bool,
     cx: &mut App,
 ) -> Option<Task<Result<ExampleSpec>>> {
@@ -34,16 +40,39 @@ pub fn capture_example(
         .or_else(|| repository_snapshot.remote_upstream_url.clone())?;
     let revision = repository_snapshot.head_commit.as_ref()?.sha.to_string();
 
-    let git_store = project.read(cx).git_store().clone();
+    Some(cx.spawn(async move |cx| {
+        let mut events = events;
+        let mut diff_buffers_by_path: HashMap<Arc<Path>, (Entity<Buffer>, Entity<BufferDiff>)> =
+            HashMap::default();
+        for stored_event in &events {
+            let zeta_prompt::Event::BufferChange { path, .. } = stored_event.event.as_ref();
+            let Some((project_path, relative_path)) = project.read_with(cx, |project, cx| {
+                let project_path = project
+                    .find_project_path(path, cx)
+                    .filter(|path| path.worktree_id == worktree_id)?;
+                let relative_path: Arc<Path> = project_path.path.as_std_path().into();
+                Some((project_path, relative_path))
+            }) else {
+                continue;
+            };
 
-    Some(cx.spawn(async move |mut cx| {
-        let snapshots_by_path =
-            collect_snapshots(&project, &git_store, worktree_id, &events, &mut cx).await?;
+            if let hash_map::Entry::Vacant(entry) = diff_buffers_by_path.entry(relative_path) {
+                let Some(diff) = uncommitted_diffs_by_path.get(entry.key()).cloned() else {
+                    continue;
+                };
+                let buffer = project
+                    .update(cx, |project, cx| {
+                        project.open_buffer(project_path.clone(), cx)
+                    })
+                    .await?;
+                entry.insert((buffer, diff));
+            }
+        }
 
         events.retain(|stored_event| {
             let zeta_prompt::Event::BufferChange { path, .. } = stored_event.event.as_ref();
             let relative_path = strip_root_name(path, &root_name);
-            snapshots_by_path.contains_key(relative_path)
+            diff_buffers_by_path.contains_key(relative_path)
         });
 
         let line_comment_prefix = snapshot
@@ -56,9 +85,17 @@ pub fn capture_example(
             .background_executor()
             .spawn(async move { compute_cursor_excerpt(&snapshot, cursor_anchor) })
             .await;
+        let uncommitted_diff_snapshots = diff_buffers_by_path
+            .into_iter()
+            .map(|(relative_path, (buffer, diff))| {
+                let snapshot = buffer.update(cx, |buffer, _| buffer.snapshot());
+                let diff_snapshot = diff.update(cx, |diff, cx| diff.snapshot(cx));
+                (relative_path, (snapshot, diff_snapshot))
+            })
+            .collect();
         let uncommitted_diff = cx
             .background_executor()
-            .spawn(async move { compute_uncommitted_diff(snapshots_by_path) })
+            .spawn(async move { compute_uncommitted_diff(uncommitted_diff_snapshots) })
             .await;
 
         let mut edit_history = String::new();
@@ -68,6 +105,7 @@ pub fn capture_example(
                 edit_history.push('\n');
             }
         }
+        let uncommitted_diff_contains_edit_history = !edit_history.is_empty();
 
         // Initialize an empty patch with context lines, to make it easy
         // to write the expected patch by hand.
@@ -100,6 +138,9 @@ pub fn capture_example(
             tags: Vec::new(),
             reasoning: None,
             uncommitted_diff,
+            recently_opened_files,
+            recently_viewed_files,
+            uncommitted_diff_contains_edit_history,
             cursor_path,
             cursor_position: String::new(),
             edit_history,
@@ -184,63 +225,107 @@ fn compute_cursor_excerpt(
     )
 }
 
-async fn collect_snapshots(
-    project: &Entity<Project>,
-    git_store: &Entity<project::git_store::GitStore>,
-    worktree_id: WorktreeId,
-    events: &[StoredEvent],
-    cx: &mut gpui::AsyncApp,
-) -> Result<HashMap<Arc<Path>, (TextBufferSnapshot, BufferDiffSnapshot)>> {
-    let mut snapshots_by_path = HashMap::default();
-    for stored_event in events {
-        let zeta_prompt::Event::BufferChange { path, .. } = stored_event.event.as_ref();
-        if let Some((project_path, relative_path)) = project.read_with(cx, |project, cx| {
-            let project_path = project
-                .find_project_path(path, cx)
-                .filter(|path| path.worktree_id == worktree_id)?;
-            let relative_path: Arc<Path> = project_path.path.as_std_path().into();
-            Some((project_path, relative_path))
-        }) {
-            if let hash_map::Entry::Vacant(entry) = snapshots_by_path.entry(relative_path) {
-                let buffer = project
-                    .update(cx, |project, cx| {
-                        project.open_buffer(project_path.clone(), cx)
-                    })
-                    .await?;
-                let diff = git_store
-                    .update(cx, |git_store, cx| {
-                        git_store.open_uncommitted_diff(buffer.clone(), cx)
-                    })
-                    .await?;
-                let diff_snapshot = diff.update(cx, |diff, cx| diff.snapshot(cx));
-                entry.insert((stored_event.old_snapshot.clone(), diff_snapshot));
-            }
-        }
-    }
-    Ok(snapshots_by_path)
-}
-
 fn compute_uncommitted_diff(
-    snapshots_by_path: HashMap<Arc<Path>, (TextBufferSnapshot, BufferDiffSnapshot)>,
+    snapshots_by_path: HashMap<Arc<Path>, (language::BufferSnapshot, BufferDiffSnapshot)>,
 ) -> String {
     let mut uncommitted_diff = String::new();
-    for (relative_path, (before_text, diff_snapshot)) in snapshots_by_path {
-        if let Some(head_text) = &diff_snapshot.base_text_string() {
-            let file_diff = language::unified_diff(head_text, &before_text.text());
-            if !file_diff.is_empty() {
-                let path_str = relative_path.to_string_lossy();
-                writeln!(uncommitted_diff, "--- a/{path_str}").ok();
-                writeln!(uncommitted_diff, "+++ b/{path_str}").ok();
-                uncommitted_diff.push_str(&file_diff);
-                if !uncommitted_diff.ends_with('\n') {
-                    uncommitted_diff.push('\n');
-                }
+    let mut snapshots_by_path = snapshots_by_path.into_iter().collect::<Vec<_>>();
+    snapshots_by_path.sort_by(|(left_path, _), (right_path, _)| left_path.cmp(right_path));
+    for (relative_path, (buffer_snapshot, diff_snapshot)) in snapshots_by_path {
+        let base_snapshot = diff_snapshot.base_text();
+        let is_existing_file = diff_snapshot.base_text_exists();
+
+        let new_path_str = relative_path.to_string_lossy();
+        let old_path_str = if is_existing_file {
+            new_path_str.as_ref()
+        } else {
+            "/dev/null"
+        };
+        writeln!(
+            uncommitted_diff,
+            "--- {}{old_path_str}",
+            if is_existing_file { "a/" } else { "" }
+        )
+        .ok();
+        writeln!(uncommitted_diff, "+++ b/{new_path_str}").ok();
+
+        if !is_existing_file {
+            let new_text = buffer_snapshot.text();
+            writeln!(
+                uncommitted_diff,
+                "@@ -0,0 +1,{} @@",
+                new_text.lines().count()
+            )
+            .ok();
+            for line in new_text.lines() {
+                writeln!(uncommitted_diff, "+{line}").ok();
             }
+            continue;
+        }
+
+        let mut ranges: Vec<(Range<u32>, Range<u32>)> = Vec::new();
+        for hunk in (&diff_snapshot).hunks(&buffer_snapshot) {
+            let old_start = base_snapshot
+                .offset_to_point(hunk.diff_base_byte_range.start)
+                .row;
+            let old_end =
+                exclusive_end_row(base_snapshot.offset_to_point(hunk.diff_base_byte_range.end));
+            let new_start = hunk.range.start.row;
+            let new_end = exclusive_end_row(hunk.range.end);
+            let old_range = old_start.saturating_sub(3)..old_end + 3;
+            let new_range = new_start.saturating_sub(3)..new_end + 3;
+
+            if let Some((last_old_range, last_new_range)) = ranges.last_mut()
+                && (old_range.start <= last_old_range.end || new_range.start <= last_new_range.end)
+            {
+                last_old_range.end = last_old_range.end.max(old_range.end);
+                last_new_range.end = last_new_range.end.max(new_range.end);
+                continue;
+            }
+            ranges.push((old_range, new_range));
+        }
+
+        for (old_range, new_range) in ranges {
+            uncommitted_diff.push_str(&language::unified_diff_with_offsets(
+                &base_snapshot
+                    .text_for_range(
+                        Point::new(old_range.start, 0)
+                            ..row_start_or_max(base_snapshot, old_range.end),
+                    )
+                    .collect::<String>(),
+                &buffer_snapshot
+                    .text_for_range(
+                        Point::new(new_range.start, 0)
+                            ..row_start_or_max(&buffer_snapshot, new_range.end),
+                    )
+                    .collect::<String>(),
+                old_range.start,
+                new_range.start,
+            ));
+        }
+        if !uncommitted_diff.ends_with('\n') {
+            uncommitted_diff.push('\n');
         }
     }
     uncommitted_diff
 }
 
+fn row_start_or_max(snapshot: &language::BufferSnapshot, row: u32) -> Point {
+    if row >= snapshot.max_point().row {
+        snapshot.max_point()
+    } else {
+        Point::new(row, 0)
+    }
+}
+
+fn exclusive_end_row(point: Point) -> u32 {
+    if point.column == 0 {
+        point.row
+    } else {
+        point.row + 1
+    }
+}
+
 fn generate_timestamp_name() -> String {
     let format = time::format_description::parse("[year]-[month]-[day] [hour]:[minute]:[second]");
     match format {
@@ -309,7 +394,9 @@ mod tests {
             json!({
                 ".git": {},
                 "src": {
+                    "deleted.rs": "pub fn deleted_file() {\n    deleted();\n}\n",
                     "main.rs": disk_contents,
+                    "new.rs": "pub fn new_file() {\n}\n",
                 }
             }),
         )
@@ -326,7 +413,13 @@ mod tests {
 
         fs.set_head_for_repo(
             Path::new("/project/.git"),
-            &[("src/main.rs", committed_contents.to_string())],
+            &[
+                (
+                    "src/deleted.rs",
+                    "pub fn deleted_file() {\n    deleted();\n}\n".to_string(),
+                ),
+                ("src/main.rs", committed_contents.to_string()),
+            ],
             "abc123def456",
         );
         fs.set_remote_for_repo(
@@ -350,6 +443,21 @@ mod tests {
         });
         cx.run_until_parked();
 
+        let deleted_file_buffer = project
+            .update(cx, |project, cx| {
+                project.open_local_buffer("/project/src/deleted.rs", cx)
+            })
+            .await
+            .unwrap();
+        ep_store.update(cx, |ep_store, cx| {
+            ep_store.register_buffer(&deleted_file_buffer, &project, cx)
+        });
+        cx.run_until_parked();
+        deleted_file_buffer.update(cx, |buffer, cx| {
+            buffer.edit([(0..buffer.len(), "")], None, cx);
+        });
+        cx.run_until_parked();
+
         buffer.update(cx, |buffer, cx| {
             let point = Point::new(6, 0);
             buffer.edit([(point..point, "    // comment 3\n")], None, cx);
@@ -379,6 +487,22 @@ mod tests {
         });
         cx.run_until_parked();
 
+        let new_file_buffer = project
+            .update(cx, |project, cx| {
+                project.open_local_buffer("/project/src/new.rs", cx)
+            })
+            .await
+            .unwrap();
+        ep_store.update(cx, |ep_store, cx| {
+            ep_store.register_buffer(&new_file_buffer, &project, cx)
+        });
+        cx.run_until_parked();
+        new_file_buffer.update(cx, |buffer, cx| {
+            let point = Point::new(1, 0);
+            buffer.edit([(point..point, "    created();\n")], None, cx);
+        });
+        cx.run_until_parked();
+
         // Open and edit an external file (outside the main project's worktree)
         let external_buffer = project
             .update(cx, |project, cx| {
@@ -410,6 +534,13 @@ mod tests {
             "external file edit should be in events"
         );
 
+        let worktree_id = buffer.read_with(cx, |buffer, cx| buffer.file().unwrap().worktree_id(cx));
+        let uncommitted_diffs_by_path = ep_store
+            .update(cx, |store, cx| {
+                store.uncommitted_diffs_for_events(project.clone(), worktree_id, events.clone(), cx)
+            })
+            .await
+            .unwrap();
         let mut example = cx
             .update(|cx| {
                 capture_example(
@@ -417,6 +548,9 @@ mod tests {
                     buffer.clone(),
                     Anchor::min_for_buffer(buffer.read(cx).remote_id()),
                     events,
+                    Vec::new(),
+                    Vec::new(),
+                    uncommitted_diffs_by_path,
                     true,
                     cx,
                 )
@@ -435,23 +569,41 @@ mod tests {
                 tags: Vec::new(),
                 reasoning: None,
                 uncommitted_diff: indoc! {"
+                    --- a/src/deleted.rs
+                    +++ b/src/deleted.rs
+                    @@ -1,3 +1,0 @@
+                    -pub fn deleted_file() {
+                    -    deleted();
+                    -}
                     --- a/src/main.rs
                     +++ b/src/main.rs
-                    @@ -1,4 +1,5 @@
+                    @@ -1,11 +1,15 @@
                      fn main() {
                     +    // comment 1
                          one();
                          two();
+                    +    // comment 4
                          three();
-                    @@ -7,5 +8,6 @@
+                         four();
+                    +    // comment 3
+                         five();
                          six();
                          seven();
                          eight();
                     +    // comment 2
                          nine();
                      }
+                    --- /dev/null
+                    +++ b/src/new.rs
+                    @@ -0,0 +1,3 @@
+                    +pub fn new_file() {
+                    +    created();
+                    +}
                 "}
                 .to_string(),
+                recently_opened_files: Vec::new(),
+                recently_viewed_files: Vec::new(),
+                uncommitted_diff_contains_edit_history: true,
                 cursor_path: Path::new("src/main.rs").into(),
                 cursor_position: indoc! {"
                     fn main() {
@@ -473,6 +625,12 @@ mod tests {
                 "}
                 .to_string(),
                 edit_history: indoc! {"
+                    --- a/src/deleted.rs
+                    +++ b/src/deleted.rs
+                    @@ -1,3 +1,0 @@
+                    -pub fn deleted_file() {
+                    -    deleted();
+                    -}
                     --- a/src/main.rs
                     +++ b/src/main.rs
                     @@ -2,8 +2,10 @@
@@ -486,6 +644,12 @@ mod tests {
                          five();
                          six();
                          seven();
+                    --- a/src/new.rs
+                    +++ b/src/new.rs
+                    @@ -1,2 +1,3 @@
+                     pub fn new_file() {
+                    +    created();
+                     }
                 "}
                 .to_string(),
                 expected_patches: vec![
diff --git a/crates/edit_prediction/src/edit_prediction.rs b/crates/edit_prediction/src/edit_prediction.rs
index 8b57c442c22..f6faa7d7123 100644
--- a/crates/edit_prediction/src/edit_prediction.rs
+++ b/crates/edit_prediction/src/edit_prediction.rs
@@ -1,4 +1,5 @@
 use anyhow::Result;
+use buffer_diff::BufferDiff;
 use client::{Client, EditPredictionUsage, UserStore, global_llm_token};
 use cloud_api_client::LlmApiToken;
 use cloud_api_types::{
@@ -88,6 +89,7 @@ mod edit_prediction_tests;
 
 use crate::cursor_excerpt::expand_context_syntactically_then_linewise;
 use crate::example_spec::ExampleSpec;
+use crate::example_spec::RecentFile;
 use crate::license_detection::LicenseDetectionWatcher;
 use crate::mercury::Mercury;
 pub use crate::metrics::{KeptRateResult, compute_kept_rate};
@@ -95,7 +97,6 @@ use crate::onboarding_modal::ZedPredictModal;
 pub use crate::prediction::EditPrediction;
 pub use crate::prediction::EditPredictionId;
 use crate::prediction::EditPredictionResult;
-pub use capture_example::capture_example;
 pub use language_model::ApiKeyState;
 pub use telemetry_events::EditPredictionRating;
 pub use zed_edit_prediction_delegate::ZedEditPredictionDelegate;
@@ -238,6 +239,7 @@ pub struct StoredEvent {
     pub old_snapshot: TextBufferSnapshot,
     pub new_snapshot_version: clock::Global,
     pub total_edit_range: Range<Anchor>,
+    pub uncommitted_diff: Option<Entity<BufferDiff>>,
 }
 
 impl StoredEvent {
@@ -572,6 +574,7 @@ impl LastEvent {
                 new_snapshot_version: self.new_snapshot.version.clone(),
                 total_edit_range: self.new_snapshot.anchor_before(edit_range.start)
                     ..self.new_snapshot.anchor_before(edit_range.end),
+                uncommitted_diff: None,
             })
         }
     }
@@ -1007,6 +1010,89 @@ impl EditPredictionStore {
             .unwrap_or_default()
     }
 
+    pub fn uncommitted_diffs_for_events(
+        &mut self,
+        project: Entity<Project>,
+        worktree_id: WorktreeId,
+        events: Vec<StoredEvent>,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<HashMap<Arc<Path>, Entity<BufferDiff>>>> {
+        let project_id = project.entity_id();
+        let git_store = project.read(cx).git_store().clone();
+        cx.spawn(async move |this, cx| {
+            let mut diffs_by_path = HashMap::default();
+            for stored_event in events.into_iter().rev() {
+                let zeta_prompt::Event::BufferChange { path, .. } = stored_event.event.as_ref();
+                let Some(project_path) = project.read_with(cx, |project, cx| {
+                    project
+                        .find_project_path(path, cx)
+                        .filter(|path| path.worktree_id == worktree_id)
+                }) else {
+                    continue;
+                };
+                let relative_path: Arc<Path> = project_path.path.as_std_path().into();
+                if diffs_by_path.contains_key(&relative_path) {
+                    continue;
+                }
+
+                let old_snapshot_remote_id = stored_event.old_snapshot.remote_id();
+                let new_snapshot_version = stored_event.new_snapshot_version.clone();
+                let event_path = path.clone();
+                if let Some(diff) = stored_event.uncommitted_diff.or_else(|| {
+                    this.update(cx, |store, _| {
+                        store
+                            .projects
+                            .get(&project_id)?
+                            .events
+                            .iter()
+                            .find(|event| {
+                                event.old_snapshot.remote_id() == old_snapshot_remote_id
+                                    && event.new_snapshot_version == new_snapshot_version
+                            })?
+                            .uncommitted_diff
+                            .clone()
+                    })
+                    .log_err()
+                    .flatten()
+                }) {
+                    diffs_by_path.insert(relative_path, diff);
+                    continue;
+                }
+
+                let buffer = project
+                    .update(cx, |project, cx| project.open_buffer(project_path, cx))
+                    .await?;
+                let diff = git_store
+                    .update(cx, |git_store, cx| {
+                        git_store.open_uncommitted_diff(buffer.clone(), cx)
+                    })
+                    .await?;
+                this.update(cx, |store, _| {
+                    let Some(project) = store.projects.get_mut(&project_id) else {
+                        return;
+                    };
+                    let Some(target_index) = project.events.iter().position(|event| {
+                        event.old_snapshot.remote_id() == old_snapshot_remote_id
+                            && event.new_snapshot_version == new_snapshot_version
+                    }) else {
+                        return;
+                    };
+                    for event in project.events.iter_mut().take(target_index + 1) {
+                        let zeta_prompt::Event::BufferChange { path, .. } = event.event.as_ref();
+                        if path == &event_path {
+                            event.uncommitted_diff = None;
+                        }
+                    }
+                    project.events[target_index].uncommitted_diff = Some(diff.clone());
+                })
+                .log_err();
+                diffs_by_path.insert(relative_path, diff);
+            }
+
+            Ok(diffs_by_path)
+        })
+    }
+
     pub fn context_for_project<'a>(
         &'a self,
         project: &Entity<Project>,
@@ -2475,6 +2561,7 @@ impl EditPredictionStore {
             && is_open_source
             && self.is_data_collection_enabled(cx)
             && matches!(self.edit_prediction_model, EditPredictionModel::Zeta);
+        let capture_worktree_id = snapshot.file().map(|file| file.worktree_id(cx));
         let inputs = EditPredictionModelInput {
             project: project.clone(),
             buffer: active_buffer,
@@ -2490,11 +2577,24 @@ impl EditPredictionStore {
             is_open_source,
         };
 
-        let capture_data = (can_collect_data && rand::random_ratio(1, 1000)).then(|| stored_events);
-
         let task = match self.edit_prediction_model {
             EditPredictionModel::Zeta => {
-                zeta::request_prediction_with_zeta(self, inputs, capture_data, cx)
+                let capture_events = (can_collect_data && rand::random_ratio(1, 10))
+                    .then(|| capture_worktree_id)
+                    .flatten()
+                    .map(|worktree_id| {
+                        (
+                            stored_events.clone(),
+                            self.uncommitted_diffs_for_events(
+                                project.clone(),
+                                worktree_id,
+                                stored_events,
+                                cx,
+                            ),
+                        )
+                    });
+
+                zeta::request_prediction_with_zeta(self, inputs, capture_events, cx)
             }
             EditPredictionModel::Fim { format } => fim::request_prediction(inputs, format, cx),
             EditPredictionModel::Mercury => {
@@ -2815,6 +2915,42 @@ impl EditPredictionStore {
         project_state.recent_paths = paths.into_iter().collect();
     }
 
+    pub fn recent_paths_for_project(
+        &self,
+        project: &Entity<Project>,
+        cx: &App,
+    ) -> (Vec<RecentFile>, Vec<RecentFile>) {
+        let recently_opened_files = project
+            .read(cx)
+            .opened_buffers(cx)
+            .into_iter()
+            .filter_map(|buffer| {
+                let snapshot = buffer.read(cx).snapshot();
+                let file = snapshot.file()?;
+                Some(RecentFile {
+                    path: file.path().as_std_path().into(),
+                    cursor_position: None,
+                })
+            })
+            .collect();
+        let recently_viewed_files = self
+            .projects
+            .get(&project.entity_id())
+            .map(|project_state| {
+                project_state
+                    .recent_paths
+                    .iter()
+                    .map(|path| RecentFile {
+                        path: path.path.as_std_path().into(),
+                        cursor_position: None,
+                    })
+                    .collect()
+            })
+            .unwrap_or_default();
+
+        (recently_opened_files, recently_viewed_files)
+    }
+
     fn is_file_open_source(
         &self,
         project: &Entity<Project>,
@@ -3035,6 +3171,7 @@ fn merge_trailing_events_if_needed(
                 new_snapshot_version: newest_snapshot.version.clone(),
                 total_edit_range: newest_snapshot.anchor_before(edit_range.start)
                     ..newest_snapshot.anchor_before(edit_range.end),
+                uncommitted_diff: None,
             },
         };
         events.truncate(events.len() - mergeable_count);
diff --git a/crates/edit_prediction/src/edit_prediction_tests.rs b/crates/edit_prediction/src/edit_prediction_tests.rs
index 86f218b401e..140b5519469 100644
--- a/crates/edit_prediction/src/edit_prediction_tests.rs
+++ b/crates/edit_prediction/src/edit_prediction_tests.rs
@@ -3603,6 +3603,9 @@ async fn test_edit_prediction_settled_omits_body_when_data_collection_is_disable
                 tags: Vec::new(),
                 reasoning: None,
                 uncommitted_diff: String::new(),
+                recently_opened_files: Vec::new(),
+                recently_viewed_files: Vec::new(),
+                uncommitted_diff_contains_edit_history: false,
                 cursor_path: Path::new("foo.md").into(),
                 cursor_position: "0".to_string(),
                 edit_history: "sensitive edit history".to_string(),
diff --git a/crates/edit_prediction/src/example_spec.rs b/crates/edit_prediction/src/example_spec.rs
index a7da51173ee..d3f4bbd3e80 100644
--- a/crates/edit_prediction/src/example_spec.rs
+++ b/crates/edit_prediction/src/example_spec.rs
@@ -13,6 +13,13 @@ pub const INLINE_CURSOR_MARKER: &str = "<|user_cursor|>";
 /// falling back to git-based loading.
 pub const MAX_CURSOR_FILE_SIZE: usize = 64 * 1024;
 
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct RecentFile {
+    pub path: Arc<Path>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub cursor_position: Option<usize>,
+}
+
 #[derive(Clone, Debug, PartialEq, Hash, Serialize, Deserialize)]
 pub struct ExampleSpec {
     #[serde(default)]
@@ -25,6 +32,12 @@ pub struct ExampleSpec {
     pub reasoning: Option<String>,
     #[serde(default)]
     pub uncommitted_diff: String,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub recently_opened_files: Vec<RecentFile>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub recently_viewed_files: Vec<RecentFile>,
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub uncommitted_diff_contains_edit_history: bool,
     pub cursor_path: Arc<Path>,
     pub cursor_position: String,
     pub edit_history: String,
@@ -56,18 +69,62 @@ pub struct TelemetrySource {
 
 const REASONING_HEADING: &str = "Reasoning";
 const UNCOMMITTED_DIFF_HEADING: &str = "Uncommitted Diff";
+const RECENTLY_OPENED_FILES_HEADING: &str = "Recently Opened Files";
+const RECENTLY_VIEWED_FILES_HEADING: &str = "Recently Viewed Files";
 const EDIT_HISTORY_HEADING: &str = "Edit History";
 const CURSOR_POSITION_HEADING: &str = "Cursor Position";
 const EXPECTED_PATCH_HEADING: &str = "Expected Patch";
 const REJECTED_PATCH_HEADING: &str = "Rejected Patch";
 const ACCEPTED_PREDICTION_MARKER: &str = "// User accepted prediction:";
 
+fn write_path_list(markdown: &mut String, heading: &str, files: &[RecentFile]) {
+    if files.is_empty() {
+        return;
+    }
+
+    _ = writeln!(markdown, "## {heading}");
+    _ = writeln!(markdown);
+    _ = writeln!(markdown, "```");
+    for file in files {
+        _ = write!(markdown, "{}", file.path.display());
+        if let Some(position) = file.cursor_position {
+            _ = write!(markdown, "\t{position}");
+        }
+        _ = writeln!(markdown);
+    }
+    _ = writeln!(markdown, "```");
+    markdown.push('\n');
+}
+
+fn parse_path_list(text: &str) -> Vec<RecentFile> {
+    text.lines()
+        .map(str::trim)
+        .filter(|line| !line.is_empty())
+        .map(|line| {
+            let (path, cursor_position) = line
+                .rsplit_once('\t')
+                .map(|(path, position)| (path, position.parse().ok()))
+                .unwrap_or((line, None));
+            RecentFile {
+                path: Path::new(path).into(),
+                cursor_position,
+            }
+        })
+        .collect()
+}
+
 #[derive(Serialize, Deserialize)]
 struct FrontMatter<'a> {
     repository_url: Cow<'a, str>,
     revision: Cow<'a, str>,
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     tags: Vec<String>,
+    #[serde(default, skip_serializing_if = "is_false")]
+    uncommitted_diff_requires_edit_history_rollback: bool,
+}
+
+fn is_false(value: &bool) -> bool {
+    !*value
 }
 
 impl ExampleSpec {
@@ -91,6 +148,8 @@ impl ExampleSpec {
             repository_url: Cow::Borrowed(&self.repository_url),
             revision: Cow::Borrowed(&self.revision),
             tags: self.tags.clone(),
+            uncommitted_diff_requires_edit_history_rollback: self
+                .uncommitted_diff_contains_edit_history,
         };
         let front_matter_toml =
             toml::to_string_pretty(&front_matter).unwrap_or_else(|_| String::new());
@@ -130,6 +189,17 @@ impl ExampleSpec {
             markdown.push('\n');
         }
 
+        write_path_list(
+            &mut markdown,
+            RECENTLY_OPENED_FILES_HEADING,
+            &self.recently_opened_files,
+        );
+        write_path_list(
+            &mut markdown,
+            RECENTLY_VIEWED_FILES_HEADING,
+            &self.recently_viewed_files,
+        );
+
         _ = writeln!(markdown, "## {}", EDIT_HISTORY_HEADING);
         _ = writeln!(markdown);
 
@@ -194,6 +264,9 @@ impl ExampleSpec {
             tags: Vec::new(),
             reasoning: None,
             uncommitted_diff: String::new(),
+            recently_opened_files: Vec::new(),
+            recently_viewed_files: Vec::new(),
+            uncommitted_diff_contains_edit_history: false,
             cursor_path: Path::new("").into(),
             cursor_position: String::new(),
             edit_history: String::new(),
@@ -211,6 +284,8 @@ impl ExampleSpec {
                 spec.repository_url = data.repository_url.into_owned();
                 spec.revision = data.revision.into_owned();
                 spec.tags = data.tags;
+                spec.uncommitted_diff_contains_edit_history =
+                    data.uncommitted_diff_requires_edit_history_rollback;
             }
             input = rest.trim_start();
         }
@@ -223,6 +298,8 @@ impl ExampleSpec {
         enum Section {
             Start,
             UncommittedDiff,
+            RecentlyOpenedFiles,
+            RecentlyViewedFiles,
             EditHistory,
             CursorPosition,
             ExpectedPatch,
@@ -245,6 +322,10 @@ impl ExampleSpec {
                     let title = mem::take(&mut text);
                     current_section = if title.eq_ignore_ascii_case(UNCOMMITTED_DIFF_HEADING) {
                         Section::UncommittedDiff
+                    } else if title.eq_ignore_ascii_case(RECENTLY_OPENED_FILES_HEADING) {
+                        Section::RecentlyOpenedFiles
+                    } else if title.eq_ignore_ascii_case(RECENTLY_VIEWED_FILES_HEADING) {
+                        Section::RecentlyViewedFiles
                     } else if title.eq_ignore_ascii_case(EDIT_HISTORY_HEADING) {
                         Section::EditHistory
                     } else if title.eq_ignore_ascii_case(CURSOR_POSITION_HEADING) {
@@ -292,6 +373,14 @@ impl ExampleSpec {
                         Section::UncommittedDiff => {
                             spec.uncommitted_diff = mem::take(&mut text);
                         }
+                        Section::RecentlyOpenedFiles => {
+                            spec.recently_opened_files = parse_path_list(&text);
+                            text.clear();
+                        }
+                        Section::RecentlyViewedFiles => {
+                            spec.recently_viewed_files = parse_path_list(&text);
+                            text.clear();
+                        }
                         Section::EditHistory => {
                             if next_edit_predicted {
                                 spec.edit_history
@@ -481,6 +570,9 @@ mod tests {
             tags: Vec::new(),
             reasoning: None,
             uncommitted_diff: String::new(),
+            recently_opened_files: Vec::new(),
+            recently_viewed_files: Vec::new(),
+            uncommitted_diff_contains_edit_history: false,
             cursor_path: Path::new("test.rs").into(),
             cursor_position: String::new(),
             edit_history: String::new(),
@@ -617,6 +709,9 @@ mod tests {
             tags: Vec::new(),
             reasoning: None,
             uncommitted_diff: String::new(),
+            recently_opened_files: Vec::new(),
+            recently_viewed_files: Vec::new(),
+            uncommitted_diff_contains_edit_history: false,
             cursor_path: Path::new("test.rs").into(),
             cursor_position: String::new(),
             edit_history: String::new(),
@@ -689,6 +784,9 @@ mod tests {
             tags: Vec::new(),
             reasoning: None,
             uncommitted_diff: String::new(),
+            recently_opened_files: Vec::new(),
+            recently_viewed_files: Vec::new(),
+            uncommitted_diff_contains_edit_history: false,
             cursor_path: Path::new("test.rs").into(),
             cursor_position: String::new(),
             edit_history: String::new(),
diff --git a/crates/edit_prediction/src/zeta.rs b/crates/edit_prediction/src/zeta.rs
index efa7552504e..f20e5786de1 100644
--- a/crates/edit_prediction/src/zeta.rs
+++ b/crates/edit_prediction/src/zeta.rs
@@ -1,11 +1,12 @@
 use crate::{
     CurrentEditPrediction, DebugEvent, EditPredictionFinishedDebugEvent, EditPredictionId,
-    EditPredictionModelInput, EditPredictionStartedDebugEvent, EditPredictionStore, StoredEvent,
+    EditPredictionModelInput, EditPredictionStartedDebugEvent, EditPredictionStore,
     ZedUpdateRequiredError, buffer_path_with_id_fallback,
     cursor_excerpt::{self, compute_cursor_excerpt, compute_syntax_ranges},
     prediction::EditPredictionResult,
 };
 use anyhow::Result;
+use buffer_diff::BufferDiff;
 use cloud_llm_client::{
     AcceptEditPredictionBody, EditPredictionRejectReason, predict_edits_v3::RawCompletionRequest,
 };
@@ -48,7 +49,10 @@ pub fn request_prediction_with_zeta(
         is_open_source,
         ..
     }: EditPredictionModelInput,
-    capture_data: Option<Vec<StoredEvent>>,
+    capture_data: Option<(
+        Vec<crate::StoredEvent>,
+        Task<Result<collections::HashMap<Arc<Path>, Entity<BufferDiff>>>>,
+    )>,
     cx: &mut Context<EditPredictionStore>,
 ) -> Task<Result<Option<EditPredictionResult>>> {
     let settings = &all_language_settings(None, cx).edit_predictions;
@@ -412,17 +416,33 @@ pub fn request_prediction_with_zeta(
             let editable_range_in_buffer = editable_range_in_buffer.clone();
             let edit_preview = prediction.edit_preview.clone();
             let model_version = prediction.model_version.clone();
-            let example_task = capture_data.and_then(|stored_events| {
-                cx.update(|cx| {
-                    crate::capture_example(
-                        project.clone(),
-                        edited_buffer.clone(),
-                        position,
-                        stored_events,
-                        false,
-                        cx,
-                    )
-                })
+            let example_task = capture_data.and_then(|(events, uncommitted_diffs)| {
+                let (recently_opened_files, recently_viewed_files) = this
+                    .read_with(cx, |this, cx| this.recent_paths_for_project(&project, cx))
+                    .ok()?;
+                Some(cx.spawn({
+                    let project = project.clone();
+                    let edited_buffer = edited_buffer.clone();
+                    async move |cx| {
+                        let uncommitted_diffs = uncommitted_diffs.await?;
+                        let Some(task) = cx.update(|cx| {
+                            crate::capture_example::capture_example(
+                                project.clone(),
+                                edited_buffer.clone(),
+                                position,
+                                events,
+                                recently_opened_files,
+                                recently_viewed_files,
+                                uncommitted_diffs,
+                                false,
+                                cx,
+                            )
+                        }) else {
+                            return Err(anyhow::anyhow!("failed to capture example"));
+                        };
+                        task.await
+                    }
+                }))
             });
             cx.spawn(async move |cx| {
                 let example_spec = if let Some(task) = example_task {
diff --git a/crates/edit_prediction_cli/src/format_prompt.rs b/crates/edit_prediction_cli/src/format_prompt.rs
index f04b2630590..e0354a78aca 100644
--- a/crates/edit_prediction_cli/src/format_prompt.rs
+++ b/crates/edit_prediction_cli/src/format_prompt.rs
@@ -854,6 +854,9 @@ mod tests {
                     tags: Vec::new(),
                     reasoning: None,
                     uncommitted_diff: String::new(),
+                    recently_opened_files: Vec::new(),
+                    recently_viewed_files: Vec::new(),
+                    uncommitted_diff_contains_edit_history: false,
                     cursor_path: std::sync::Arc::from(std::path::Path::new("src/main.rs")),
                     cursor_position: "0:0".to_string(),
                     edit_history: String::new(),
@@ -933,6 +936,9 @@ mod tests {
                     tags: Vec::new(),
                     reasoning: None,
                     uncommitted_diff: String::new(),
+                    recently_opened_files: Vec::new(),
+                    recently_viewed_files: Vec::new(),
+                    uncommitted_diff_contains_edit_history: false,
                     cursor_path: std::sync::Arc::from(std::path::Path::new("src/main.rs")),
                     cursor_position: "0:0".to_string(),
                     edit_history: String::new(),
diff --git a/crates/edit_prediction_cli/src/pull_examples.rs b/crates/edit_prediction_cli/src/pull_examples.rs
index 9062d973ffa..88de3053d85 100644
--- a/crates/edit_prediction_cli/src/pull_examples.rs
+++ b/crates/edit_prediction_cli/src/pull_examples.rs
@@ -1754,6 +1754,9 @@ fn build_example_from_snowflake(
         tags,
         reasoning: None,
         uncommitted_diff: String::new(),
+        recently_opened_files: Vec::new(),
+        recently_viewed_files: Vec::new(),
+        uncommitted_diff_contains_edit_history: false,
         cursor_path: input.cursor_path.clone(),
         cursor_position: build_cursor_position(cursor_excerpt, cursor_offset),
         edit_history,
diff --git a/crates/edit_prediction_cli/src/repair.rs b/crates/edit_prediction_cli/src/repair.rs
index 2ae62fd70f8..751e55a8b1c 100644
--- a/crates/edit_prediction_cli/src/repair.rs
+++ b/crates/edit_prediction_cli/src/repair.rs
@@ -549,6 +549,9 @@ mod tests {
                 tags: Vec::new(),
                 reasoning: None,
                 uncommitted_diff: String::new(),
+                recently_opened_files: Vec::new(),
+                recently_viewed_files: Vec::new(),
+                uncommitted_diff_contains_edit_history: false,
                 cursor_path: Arc::from(Path::new("src/main.rs")),
                 cursor_position: "0:0".to_string(),
                 edit_history: String::new(),
diff --git a/crates/edit_prediction_cli/src/split_commit.rs b/crates/edit_prediction_cli/src/split_commit.rs
index b70ac354b5c..2421a81f3c5 100644
--- a/crates/edit_prediction_cli/src/split_commit.rs
+++ b/crates/edit_prediction_cli/src/split_commit.rs
@@ -370,6 +370,9 @@ pub fn generate_evaluation_example_from_ordered_commit(
         tags: vec![],
         reasoning: None,
         uncommitted_diff: String::new(),
+        recently_opened_files: Vec::new(),
+        recently_viewed_files: Vec::new(),
+        uncommitted_diff_contains_edit_history: false,
         rejected_patch: None,
 
         telemetry: None,
@@ -1369,6 +1372,9 @@ Date: Mon Jan 1 00:00:00 2024
             tags: vec![],
             reasoning: None,
             uncommitted_diff: String::new(),
+            recently_opened_files: Vec::new(),
+            recently_viewed_files: Vec::new(),
+            uncommitted_diff_contains_edit_history: false,
             rejected_patch: None,
 
             telemetry: None,
diff --git a/crates/edit_prediction_cli/src/synthesize.rs b/crates/edit_prediction_cli/src/synthesize.rs
index 228690ae49e..76c8e0fee37 100644
--- a/crates/edit_prediction_cli/src/synthesize.rs
+++ b/crates/edit_prediction_cli/src/synthesize.rs
@@ -790,6 +790,9 @@ async fn build_example(
         tags: Vec::new(),
         reasoning: Some(reasoning_with_source),
         uncommitted_diff: String::new(),
+        recently_opened_files: Vec::new(),
+        recently_viewed_files: Vec::new(),
+        uncommitted_diff_contains_edit_history: false,
         cursor_path: Arc::from(Path::new(&cursor_file)),
         cursor_position: String::new(),
         edit_history,
diff --git a/crates/edit_prediction_ui/src/edit_prediction_button.rs b/crates/edit_prediction_ui/src/edit_prediction_button.rs
index 2246f106e72..cd3164d2eea 100644
--- a/crates/edit_prediction_ui/src/edit_prediction_button.rs
+++ b/crates/edit_prediction_ui/src/edit_prediction_button.rs
@@ -42,9 +42,7 @@ use workspace::{
 };
 use zed_actions::{OpenBrowser, OpenSettingsAt};
 
-use crate::{
-    CaptureExample, RatePredictions, rate_prediction_modal::PredictEditsRatePredictionsFeatureFlag,
-};
+use crate::{RatePredictions, rate_prediction_modal::PredictEditsRatePredictionsFeatureFlag};
 
 actions!(
     edit_prediction,
@@ -982,10 +980,7 @@ impl EditPredictionButton {
                 .context(editor_focus_handle)
                 .when(
                     cx.has_flag::<PredictEditsRatePredictionsFeatureFlag>(),
-                    |this| {
-                        this.action("Capture Prediction Example", CaptureExample.boxed_clone())
-                            .action("Rate Predictions", RatePredictions.boxed_clone())
-                    },
+                    |this| this.action("Rate Predictions", RatePredictions.boxed_clone()),
                 );
         }
 
diff --git a/crates/edit_prediction_ui/src/edit_prediction_ui.rs b/crates/edit_prediction_ui/src/edit_prediction_ui.rs
index 05f1224f506..26563754575 100644
--- a/crates/edit_prediction_ui/src/edit_prediction_ui.rs
+++ b/crates/edit_prediction_ui/src/edit_prediction_ui.rs
@@ -3,13 +3,10 @@ mod edit_prediction_context_view;
 mod rate_prediction_modal;
 
 use command_palette_hooks::CommandPaletteFilter;
-use edit_prediction::{EditPredictionStore, ResetOnboarding, capture_example};
+use edit_prediction::ResetOnboarding;
 use edit_prediction_context_view::EditPredictionContextView;
-use editor::Editor;
 use feature_flags::FeatureFlagAppExt as _;
-use gpui::TaskExt;
 use gpui::actions;
-use language::language_settings::AllLanguageSettings;
 use project::DisableAiSettings;
 use rate_prediction_modal::RatePredictionsModal;
 use settings::{Settings as _, SettingsStore};
@@ -36,8 +33,6 @@ actions!(
     [
         /// Opens the rate completions modal.
         RatePredictions,
-        /// Captures an ExampleSpec from the current editing session and opens it as Markdown.
-        CaptureExample,
     ]
 );
 
@@ -51,9 +46,6 @@ pub fn init(cx: &mut App) {
             }
         });
 
-        workspace.register_action(|workspace, _: &CaptureExample, window, cx| {
-            capture_example_as_markdown(workspace, window, cx);
-        });
         workspace.register_action_renderer(|div, _, _, cx| {
             div.on_action(cx.listener(
                 move |workspace, _: &OpenEditPredictionContextView, window, cx| {
@@ -84,7 +76,6 @@ fn feature_gate_predict_edits_actions(cx: &mut App) {
     let reset_onboarding_action_types = [TypeId::of::<ResetOnboarding>()];
     let all_action_types = [
         TypeId::of::<RatePredictions>(),
-        TypeId::of::<CaptureExample>(),
         TypeId::of::<edit_prediction::ResetOnboarding>(),
         zed_actions::OpenZedPredictOnboarding.type_id(),
         TypeId::of::<edit_prediction::ClearHistory>(),
@@ -131,68 +122,3 @@ fn feature_gate_predict_edits_actions(cx: &mut App) {
     })
     .detach();
 }
-
-fn capture_example_as_markdown(
-    workspace: &mut Workspace,
-    window: &mut Window,
-    cx: &mut Context<Workspace>,
-) -> Option<()> {
-    let markdown_language = workspace
-        .app_state()
-        .languages
-        .language_for_name("Markdown");
-
-    let fs = workspace.app_state().fs.clone();
-    let project = workspace.project().clone();
-    let editor = workspace.active_item_as::<Editor>(cx)?;
-    let editor = editor.read(cx);
-    let (buffer, cursor_anchor) = editor
-        .buffer()
-        .read(cx)
-        .text_anchor_for_position(editor.selections.newest_anchor().head(), cx)?;
-    let ep_store = EditPredictionStore::try_global(cx)?;
-    let events = ep_store.update(cx, |store, cx| store.edit_history_for_project(&project, cx));
-    let example = capture_example(project.clone(), buffer, cursor_anchor, events, true, cx)?;
-
-    let examples_dir = AllLanguageSettings::get_global(cx)
-        .edit_predictions
-        .examples_dir
-        .clone();
-
-    cx.spawn_in(window, async move |workspace_entity, cx| {
-        let markdown_language = markdown_language.await?;
-        let example_spec = example.await?;
-        let buffer = if let Some(dir) = examples_dir {
-            fs.create_dir(&dir).await.ok();
-            let mut path = dir.join(&example_spec.name.replace(' ', "--").replace(':', "-"));
-            path.set_extension("md");
-            project
-                .update(cx, |project, cx| project.open_local_buffer(&path, cx))
-                .await?
-        } else {
-            project
-                .update(cx, |project, cx| {
-                    project.create_buffer(Some(markdown_language.clone()), false, cx)
-                })
-                .await?
-        };
-
-        buffer.update(cx, |buffer, cx| {
-            buffer.set_text(example_spec.to_markdown(), cx);
-            buffer.set_language(Some(markdown_language), cx);
-        });
-        workspace_entity.update_in(cx, |workspace, window, cx| {
-            workspace.add_item_to_active_pane(
-                Box::new(
-                    cx.new(|cx| Editor::for_buffer(buffer, Some(project.clone()), window, cx)),
-                ),
-                None,
-                true,
-                window,
-                cx,
-            );
-        })
-    })
-    .detach_and_log_err(cx);
-    None
-}
diff --git a/crates/language/src/language_settings.rs b/crates/language/src/language_settings.rs
index 3d90d8d06e6..de67375cccc 100644
--- a/crates/language/src/language_settings.rs
+++ b/crates/language/src/language_settings.rs
@@ -477,7 +477,6 @@ pub struct EditPredictionSettings {
     /// Settings specific to Ollama.
     pub ollama: Option<OpenAiCompatibleEditPredictionSettings>,
     pub open_ai_compatible_api: Option<OpenAiCompatibleEditPredictionSettings>,
-    pub examples_dir: Option<Arc<Path>>,
     /// Controls whether training data collection is enabled.
     ///
     /// `Default` means the value stored in the legacy KV store is used as a fallback,
@@ -911,7 +910,6 @@ impl settings::Settings for AllLanguageSettings {
                 codestral: codestral_settings,
                 ollama: ollama_settings,
                 open_ai_compatible_api: openai_compatible_settings,
-                examples_dir: edit_predictions.examples_dir,
                 allow_data_collection: edit_predictions.allow_data_collection.unwrap_or_default(),
             },
             defaults: default_language_settings,
diff --git a/crates/settings_content/src/language.rs b/crates/settings_content/src/language.rs
index 081406a6846..2e5ef23875e 100644
--- a/crates/settings_content/src/language.rs
+++ b/crates/settings_content/src/language.rs
@@ -1,4 +1,4 @@
-use std::{num::NonZeroU32, path::Path};
+use std::num::NonZeroU32;
 
 use collections::{HashMap, HashSet};
 use schemars::JsonSchema;
@@ -137,8 +137,6 @@ pub struct EditPredictionSettingsContent {
     pub ollama: Option<OllamaEditPredictionSettingsContent>,
     /// Settings specific to using custom OpenAI-compatible servers for edit prediction.
     pub open_ai_compatible_api: Option<CustomEditPredictionProviderSettingsContent>,
-    /// The directory where manually captured edit prediction examples are stored.
-    pub examples_dir: Option<Arc<Path>>,
     /// Controls whether Zed may collect training data when using Zed's Edit Predictions.
     /// Data is only ever captured for files in projects that are detected as open source.
     ///

From 33eb2d83ed1a9f9ac7ca533178fa866cd4416edc Mon Sep 17 00:00:00 2001
From: MartinYe1234 <52641447+MartinYe1234@users.noreply.github.com>
Date: Thu, 21 May 2026 09:16:49 -0700
Subject: [PATCH 089/105] Skip syntax highlighting for read_file outline
 responses (#57287)

When `read_file` returns a file outline instead of full contents, the
result is now wrapped in a plain fenced code block rather than tagging
it with the file's path.

Previously, the outline was wrapped in a fenced block tagged with the
file path (e.g. `` ```crates/agent/src/tools/read_file_tool.rs ``).
Because the tag contains a slash, the markdown parser routed it through
`CodeBlockKind::FencedSrc`, resolved the file's language by path, and
ran the language's tree-sitter parser against the outline on every
paint. The outline is structural (e.g. `fn foo [L10-20]`), not actual
source for the file's language, so the parse was both expensive and
produced incorrect highlighting.

Because GPUI rebuilds the visible element tree on every window paint,
anything that triggers a repaint (cursor blink in the focused message
editor, animations, the turn timer, etc.) would re-run the tree-sitter
parse on the entire outline, throttling the frame rate while the tool
call was expanded.

This change adds an `is_outline_response` flag in `ReadFileTool::run`
and, when set, passes an empty tag to `MarkdownCodeBlock` so the
renderer sees `CodeBlockKind::Fenced` (no language). Plain monospace
formatting is preserved; the path tag is still used for the non-outline
(full file) case.

Adds two regression tests: one asserting the outline path uses an
untagged fenced block, and one asserting the full-file path keeps the
path tag (so the next person fixing this doesn't accidentally strip the
tag everywhere).

Also includes a small markdown-rendering follow-up:
`MarkdownElementBuilder::push_text` was recomputing the base text style
(cloning `base_text_style` and walking the style stack) twice per
highlighted token. For a code block with hundreds of highlight tokens,
that's hundreds of redundant `TextStyle` clones per paint. The style
stack does not change while runs are being attributed, so the style is
now computed once outside the loop and reused.

Closes AI-234

Release Notes:

- Improved scrolling smoothness in the agent panel when a `read_file`
tool call with a large file outline is expanded.
---
 crates/agent/src/tools/read_file_tool.rs | 139 ++++++++++++++++++++++-
 crates/markdown/src/markdown.rs          |  21 ++--
 2 files changed, 146 insertions(+), 14 deletions(-)

diff --git a/crates/agent/src/tools/read_file_tool.rs b/crates/agent/src/tools/read_file_tool.rs
index 95301ee1523..4638b170314 100644
--- a/crates/agent/src/tools/read_file_tool.rs
+++ b/crates/agent/src/tools/read_file_tool.rs
@@ -338,6 +338,7 @@ impl AgentTool for ReadFileTool {
             }
 
             let mut anchor = None;
+            let mut is_outline_response = false;
 
             // Check if specific line ranges are provided
             let result = if input.start_line.is_some() || input.end_line.is_some() {
@@ -377,6 +378,8 @@ impl AgentTool for ReadFileTool {
                     log.buffer_read(buffer.clone(), cx);
                 });
 
+                is_outline_response = buffer_content.is_outline;
+
                 if buffer_content.is_outline {
                     Ok(formatdoc! {"
                         SUCCESS: File outline retrieved. This file is too large to read all at once, so the outline below shows the file's structure with line numbers.
@@ -409,11 +412,12 @@ impl AgentTool for ReadFileTool {
                 }
                 if let Ok(LanguageModelToolResultContent::Text(text)) = &result {
                     let text: &str = text;
-                    let markdown = MarkdownCodeBlock {
-                        tag: &input.path,
-                        text,
-                    }
-                    .to_string();
+                    // For outline responses, omit the path tag so the markdown renderer
+                    // does not invoke tree-sitter syntax highlighting against pseudo-code
+                    // outline text. The outline is not valid source for the file's language,
+                    // so highlighting would be both expensive and incorrect.
+                    let tag: &str = if is_outline_response { "" } else { &input.path };
+                    let markdown = MarkdownCodeBlock { tag, text }.to_string();
                     event_stream.update_fields(acp::ToolCallUpdateFields::new().content(vec![
                         acp::ToolCallContent::Content(acp::Content::new(markdown)),
                     ]));
@@ -610,6 +614,131 @@ mod test {
         );
     }
 
+    // The outline returned for a large file is not valid source for the file's
+    // language, so the UI-side markdown wrapping must omit the path tag.
+    // Otherwise the markdown renderer routes the fenced block through
+    // `CodeBlockKind::FencedSrc`, resolves the file's language, and runs
+    // tree-sitter against pseudo-code outline text on every paint.
+    #[gpui::test]
+    async fn test_outline_response_uses_untagged_code_block(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(
+            path!("/root"),
+            json!({
+                "large_file.rs": (0..1000).map(|i| format!("struct Test{} {{\n    a: u32,\n    b: usize,\n}}", i)).collect::<Vec<_>>().join("\n")
+            }),
+        )
+        .await;
+        let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await;
+        let language_registry = project.read_with(cx, |project, _| project.languages().clone());
+        language_registry.add(language::rust_lang());
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
+        let tool = Arc::new(ReadFileTool::new(project, action_log, true));
+        let (event_stream, mut rx) = ToolCallEventStream::test();
+
+        let result = cx
+            .update(|cx| {
+                let input = ReadFileToolInput {
+                    path: "root/large_file.rs".into(),
+                    start_line: None,
+                    end_line: None,
+                };
+                tool.clone()
+                    .run(ToolInput::resolved(input), event_stream, cx)
+            })
+            .await
+            .unwrap();
+
+        // Sanity-check: the file is large enough to trigger the outline branch.
+        assert!(
+            result
+                .to_str()
+                .unwrap()
+                .starts_with("SUCCESS: File outline retrieved."),
+            "expected outline response, got: {:?}",
+            result.to_str().unwrap()
+        );
+
+        // The first update carries the location; the second carries the
+        // markdown content destined for the tool-call UI.
+        let _location_update = rx.expect_update_fields().await;
+        let content_update = rx.expect_update_fields().await;
+        let content_blocks = content_update.content.expect("expected content update");
+        let acp::ToolCallContent::Content(content) = content_blocks
+            .first()
+            .expect("expected at least one content block")
+        else {
+            panic!("expected ContentBlock, got {:?}", content_blocks.first());
+        };
+        let acp::ContentBlock::Text(text) = &content.content else {
+            panic!("expected text content block, got {:?}", content.content);
+        };
+
+        assert!(
+            text.text.starts_with("```\n"),
+            "outline response must use an untagged fenced code block; got first line: {:?}",
+            text.text.lines().next()
+        );
+        assert!(
+            !text.text.starts_with("```root/"),
+            "outline response must not include the file path as a code block tag"
+        );
+    }
+
+    // The full-file (non-outline) response should still tag the code block
+    // with the file path so the markdown renderer can resolve the file's
+    // language for syntax highlighting.
+    #[gpui::test]
+    async fn test_full_file_response_keeps_path_tag(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(
+            path!("/root"),
+            json!({
+                "small_file.rs": "fn main() {}"
+            }),
+        )
+        .await;
+        let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await;
+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
+        let tool = Arc::new(ReadFileTool::new(project, action_log, true));
+        let (event_stream, mut rx) = ToolCallEventStream::test();
+
+        cx.update(|cx| {
+            let input = ReadFileToolInput {
+                path: "root/small_file.rs".into(),
+                start_line: None,
+                end_line: None,
+            };
+            tool.clone()
+                .run(ToolInput::resolved(input), event_stream, cx)
+        })
+        .await
+        .unwrap();
+
+        let _location_update = rx.expect_update_fields().await;
+        let content_update = rx.expect_update_fields().await;
+        let content_blocks = content_update.content.expect("expected content update");
+        let acp::ToolCallContent::Content(content) = content_blocks
+            .first()
+            .expect("expected at least one content block")
+        else {
+            panic!("expected ContentBlock, got {:?}", content_blocks.first());
+        };
+        let acp::ContentBlock::Text(text) = &content.content else {
+            panic!("expected text content block, got {:?}", content.content);
+        };
+
+        assert!(
+            text.text.starts_with("```root/small_file.rs\n"),
+            "full-file response must tag the code block with the file path; got first line: {:?}",
+            text.text.lines().next()
+        );
+    }
+
     // When a worktree is named "foo" and contains a subdirectory also named "foo",
     // read_file({"path": "foo/test.txt"}) should return the file at the worktree
     // root (as the tool schema promises), not the one inside the foo/ subdirectory.
diff --git a/crates/markdown/src/markdown.rs b/crates/markdown/src/markdown.rs
index 1f763d390b9..f8ca35d7225 100644
--- a/crates/markdown/src/markdown.rs
+++ b/crates/markdown/src/markdown.rs
@@ -2862,33 +2862,36 @@ impl MarkdownElementBuilder {
         self.pending_line.text.push_str(text);
         self.current_source_index = source_range.end;
 
+        // Compute the base text style once
+        let text_style = self.text_style();
+
         if let Some(Some(language)) = self.code_block_stack.last() {
             let mut offset = 0;
             for (range, highlight_id) in language.highlight_text(&Rope::from(text), 0..text.len()) {
                 if range.start > offset {
                     self.pending_line
                         .runs
-                        .push(self.text_style().to_run(range.start - offset));
+                        .push(text_style.to_run(range.start - offset));
                 }
 
-                let mut run_style = self.text_style();
+                let run_len = range.len();
                 if let Some(highlight) = self.syntax_theme.get(highlight_id).cloned() {
-                    run_style = run_style.highlight(highlight);
+                    self.pending_line
+                        .runs
+                        .push(text_style.clone().highlight(highlight).to_run(run_len));
+                } else {
+                    self.pending_line.runs.push(text_style.to_run(run_len));
                 }
-
-                self.pending_line.runs.push(run_style.to_run(range.len()));
                 offset = range.end;
             }
 
             if offset < text.len() {
                 self.pending_line
                     .runs
-                    .push(self.text_style().to_run(text.len() - offset));
+                    .push(text_style.to_run(text.len() - offset));
             }
         } else {
-            self.pending_line
-                .runs
-                .push(self.text_style().to_run(text.len()));
+            self.pending_line.runs.push(text_style.to_run(text.len()));
         }
     }
 

From 0307c7fb355c32e00b0ce913e277ea6b0fddd7c5 Mon Sep 17 00:00:00 2001
From: MartinYe1234 <52641447+MartinYe1234@users.noreply.github.com>
Date: Thu, 21 May 2026 12:29:31 -0700
Subject: [PATCH 090/105] agent_ui: Fix crash when opening built-in skill
 mention in remote projects (#57432)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Clicking a built-in skill mention while connected to a remote project
(SSH or collab) caused Zed to abort with `called create_local_buffer on
a remote project`.

## Root cause

`agent_ui::ui::mention_crease::open_skill_file` was calling
`Project::create_local_buffer` to display the embedded read-only content
of a built-in skill:

```rust
let buffer = project.update(cx, |project, cx| {
    project.create_local_buffer(content, None, false, cx)
});
```

`Project::create_local_buffer` has an explicit panic guard for remote
projects, so any user who clicked a built-in skill mention while in an
SSH or collab project would crash Zed.

## Fix

The buffer is purely a display surface for binary-embedded skill content
— it has no on-disk backing, isn't searchable, and never needs to be
tracked by the project's buffer store. Build it directly with
`language::Buffer::local(content, cx)` instead, matching the pattern
used elsewhere in `agent_ui` (`thread_view.rs`, `message_editor.rs`,
`inline_assistant.rs`, etc.). This works for both local and remote
projects.

## Repro (before fix)

1. Connect Zed to a remote (SSH) project.
2. In the agent panel, click on a built-in skill mention (e.g. one
referencing `create-skill`).
3. Zed aborts with SIGABRT.

After the fix, the mention opens a read-only editor with the embedded
markdown content, identical behavior to local projects.

Release Notes:

- Fixed a crash when clicking a built-in skill mention in the agent
panel while connected to a remote project
---
 crates/agent_ui/src/ui/mention_crease.rs | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/crates/agent_ui/src/ui/mention_crease.rs b/crates/agent_ui/src/ui/mention_crease.rs
index f71ecedae21..41e3d5cef5d 100644
--- a/crates/agent_ui/src/ui/mention_crease.rs
+++ b/crates/agent_ui/src/ui/mention_crease.rs
@@ -7,6 +7,7 @@ use gpui::{
     Animation, AnimationExt, AnyView, Context, IntoElement, TaskExt, WeakEntity, Window,
     pulsating_between,
 };
+use language::Buffer;
 use prompt_store::PromptId;
 use rope::Point;
 use settings::Settings;
@@ -205,12 +206,15 @@ fn open_skill_file(
 ) {
     // Built-in skills have synthetic paths that don't exist on disk.
     // Open a read-only buffer with the embedded content instead.
+    //
+    // The buffer is intentionally not registered with the project's buffer
+    // store: it has no on-disk backing, isn't searchable, and `Project::
+    // create_local_buffer` panics for remote projects (SSH/collab), which
+    // would crash Zed if a user clicked a built-in skill mention while
+    // connected to a remote project.
     if let Some(content) = agent_skills::builtin_skill_content(&skill_file_path) {
-        let project = workspace.project().clone();
-        let languages = project.read(cx).languages().clone();
-        let buffer = project.update(cx, |project, cx| {
-            project.create_local_buffer(content, None, false, cx)
-        });
+        let languages = workspace.project().read(cx).languages().clone();
+        let buffer = cx.new(|cx| Buffer::local(content, cx));
         // Set markdown highlighting asynchronously — the buffer
         // opens instantly and the highlighting appears once loaded.
         cx.spawn({

From 7afcc8792718d49ccb2b58005810b322f54488e1 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Thu, 21 May 2026 16:29:55 -0300
Subject: [PATCH 091/105] agent_ui: Add skills menu item in message editor's
 context menu (#57407)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closes AI-295

This PR adds a skills submenu within the "add context" menu in the agent
panel's message editor. This will hopefully be yet another way to find
skills in the app.

<img width="600" alt="Screenshot 2026-05-21 at 11  24@2x"
src="https://github.com/user-attachments/assets/43652081-3929-4ca0-a32b-464077d84dd5"
/>

Release Notes:

- N/A
---
 .../src/conversation_view/thread_view.rs      | 49 ++++++++++++-----
 crates/agent_ui/src/message_editor.rs         | 55 +++++++++++++++++++
 2 files changed, 89 insertions(+), 15 deletions(-)

diff --git a/crates/agent_ui/src/conversation_view/thread_view.rs b/crates/agent_ui/src/conversation_view/thread_view.rs
index cc182096d18..3b0c0dd37cc 100644
--- a/crates/agent_ui/src/conversation_view/thread_view.rs
+++ b/crates/agent_ui/src/conversation_view/thread_view.rs
@@ -12,6 +12,7 @@ use cloud_api_types::{SubmitAgentThreadFeedbackBody, SubmitAgentThreadFeedbackCo
 use editor::actions::OpenExcerpts;
 use feature_flags::AcpBetaFeatureFlag;
 
+use crate::completion_provider::AvailableSkill;
 use crate::message_editor::SharedSessionCapabilities;
 
 use gpui::List;
@@ -4157,6 +4158,8 @@ impl ThreadView {
         let session_capabilities = self.session_capabilities.read();
         let supports_images = session_capabilities.supports_images();
         let supports_embedded_context = session_capabilities.supports_embedded_context();
+        let available_skills = session_capabilities.completion_skills();
+        drop(session_capabilities);
 
         let has_editor_selection = workspace
             .upgrade()
@@ -4180,7 +4183,6 @@ impl ThreadView {
 
         ContextMenu::build(window, cx, move |menu, _window, _cx| {
             menu.key_context("AddContextMenu")
-                .header("Context")
                 .item(
                     ContextMenuEntry::new("Files & Directories")
                         .icon(IconName::File)
@@ -4226,21 +4228,19 @@ impl ThreadView {
                             }
                         }),
                 )
-                .item(
-                    ContextMenuEntry::new("Skills")
-                        .icon(IconName::Sparkle)
-                        .icon_color(Color::Muted)
-                        .icon_size(IconSize::XSmall)
-                        .handler({
-                            let message_editor = message_editor.clone();
-                            move |window, cx| {
-                                message_editor.focus_handle(cx).focus(window, cx);
-                                message_editor.update(cx, |editor, cx| {
-                                    editor.insert_context_type("skill", window, cx);
-                                });
+                .when(!available_skills.is_empty(), |this| {
+                    this.submenu_with_colored_icon("Skills", IconName::Sparkle, Color::Muted, {
+                        let message_editor = message_editor.clone();
+                        let available_skills = available_skills.clone();
+                        move |mut menu, _window, _cx| {
+                            for skill in &available_skills {
+                                menu = menu
+                                    .item(Self::skill_menu_entry(skill, message_editor.clone()));
                             }
-                        }),
-                )
+                            menu
+                        }
+                    })
+                })
                 .item(
                     ContextMenuEntry::new("Image")
                         .icon(IconName::Image)
@@ -4289,6 +4289,25 @@ impl ThreadView {
         })
     }
 
+    fn skill_menu_entry(
+        skill: &AvailableSkill,
+        message_editor: Entity<crate::message_editor::MessageEditor>,
+    ) -> ContextMenuEntry {
+        let label = format!("{} ({})", skill.name, skill.source);
+        let skill = skill.clone();
+
+        ContextMenuEntry::new(label)
+            .icon(IconName::Sparkle)
+            .icon_color(Color::Muted)
+            .icon_size(IconSize::XSmall)
+            .handler(move |window, cx| {
+                message_editor.focus_handle(cx).focus(window, cx);
+                message_editor.update(cx, |editor, cx| {
+                    editor.insert_skill_crease(&skill, window, cx);
+                });
+            })
+    }
+
     fn render_follow_toggle(&self, cx: &mut Context<Self>) -> impl IntoElement {
         let following = self.is_following(cx);
 
diff --git a/crates/agent_ui/src/message_editor.rs b/crates/agent_ui/src/message_editor.rs
index ecd1febba72..90cbdffb6db 100644
--- a/crates/agent_ui/src/message_editor.rs
+++ b/crates/agent_ui/src/message_editor.rs
@@ -1514,6 +1514,61 @@ impl MessageEditor {
             .detach_and_log_err(cx);
     }
 
+    pub fn insert_skill_crease(
+        &mut self,
+        skill: &AvailableSkill,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(workspace) = self.workspace.upgrade() else {
+            return;
+        };
+
+        let mention_uri = MentionUri::Skill {
+            name: skill.name.to_string(),
+            source: skill.source.to_string(),
+            skill_file_path: skill.skill_file_path.clone(),
+        };
+
+        let link_text = mention_uri.as_link().to_string();
+        let content_len = link_text.len();
+        let mention_text = format!("{} ", link_text);
+        let crease_text: SharedString = mention_uri.name().into();
+
+        let start_anchor = self.editor.update(cx, |editor, cx| {
+            let snapshot = editor.buffer().read(cx).snapshot(cx);
+            let buffer_snapshot = snapshot.as_singleton()?;
+            let cursor = editor.selections.newest_anchor().start;
+            let text_anchor = snapshot
+                .anchor_to_buffer_anchor(cursor)?
+                .0
+                .bias_left(buffer_snapshot);
+
+            editor.insert(&mention_text, window, cx);
+            Some(text_anchor)
+        });
+
+        let Some(start_anchor) = start_anchor else {
+            return;
+        };
+
+        self.mention_set
+            .update(cx, |mention_set, cx| {
+                mention_set.confirm_mention_completion(
+                    crease_text,
+                    start_anchor,
+                    content_len,
+                    mention_uri,
+                    false,
+                    self.editor.clone(),
+                    &workspace,
+                    window,
+                    cx,
+                )
+            })
+            .detach();
+    }
+
     pub(crate) fn insert_selections(
         &mut self,
         selection: AgentContextSelection,

From 7ec36d3661e99d33b00bace2cbfeffff7bd56772 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Thu, 21 May 2026 16:35:43 -0300
Subject: [PATCH 092/105] sidebar: Show pending/unread state in project header
 when collapsed (#57322)

Closes AI-285

Similar to how we display whether there are running threads or a thread
waiting for permission in the collapsed version of the project's header
in the sidebar, I was missing the "unread" state from being shown. I had
to change the approach here as to how we extract this information
because the previous method was relying on observing the state of the
list entries within the sidebar at every `rebuild_contents` run, and
given there aren't any list entires when the project is collapsed, it
wouldn't work.
Release Notes:

- Agent: Added the notification indicator on collapsed project headers
in the sidebar when a thread completes.
---
 assets/icons/circle.svg             |   2 +-
 crates/sidebar/src/sidebar.rs       | 110 ++++++++++++++++++++++++----
 crates/sidebar/src/sidebar_tests.rs |   2 +
 3 files changed, 97 insertions(+), 17 deletions(-)

diff --git a/assets/icons/circle.svg b/assets/icons/circle.svg
index 1d80edac09e..c33c37f5f9d 100644
--- a/assets/icons/circle.svg
+++ b/assets/icons/circle.svg
@@ -1,3 +1,3 @@
 <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M8 11C9.65685 11 11 9.65685 11 8C11 6.34315 9.65685 5 8 5C6.34315 5 5 6.34315 5 8C5 9.65685 6.34315 11 8 11Z" fill="black"/>
+<path d="M8 12C10.2091 12 12 10.2091 12 8C12 5.79087 10.2091 4 8 4C5.79087 4 4 5.79087 4 8C4 10.2091 5.79087 12 8 12Z" fill="#C6CAD0"/>
 </svg>
diff --git a/crates/sidebar/src/sidebar.rs b/crates/sidebar/src/sidebar.rs
index 199c453d092..78c941aa399 100644
--- a/crates/sidebar/src/sidebar.rs
+++ b/crates/sidebar/src/sidebar.rs
@@ -303,6 +303,7 @@ enum ListEntry {
         highlight_positions: Vec<usize>,
         has_running_threads: bool,
         waiting_thread_count: usize,
+        has_notifications: bool,
         is_active: bool,
         has_threads: bool,
     },
@@ -654,6 +655,10 @@ pub struct Sidebar {
     thread_switcher: Option<Entity<ThreadSwitcher>>,
     _thread_switcher_subscriptions: Vec<gpui::Subscription>,
     pending_thread_activation: Option<agent_ui::ThreadId>,
+    /// Persists live thread statuses across rebuilds so that Running→Completed
+    /// transitions can be detected even when the group is collapsed (and
+    /// thread entries are not present in the list).
+    live_thread_statuses: HashMap<acp::SessionId, (AgentThreadStatus, ThreadId)>,
     view: SidebarView,
     restoring_tasks: HashMap<agent_ui::ThreadId, Task<()>>,
     recent_projects_popover_handle: PopoverMenuHandle<SidebarRecentProjects>,
@@ -762,6 +767,7 @@ impl Sidebar {
             thread_switcher: None,
             _thread_switcher_subscriptions: Vec::new(),
             pending_thread_activation: None,
+            live_thread_statuses: HashMap::new(),
             view: SidebarView::default(),
             restoring_tasks: HashMap::new(),
             recent_projects_popover_handle: PopoverMenuHandle::default(),
@@ -1205,21 +1211,13 @@ impl Sidebar {
 
         let previous = mem::take(&mut self.contents);
 
-        let old_statuses: HashMap<acp::SessionId, AgentThreadStatus> = previous
-            .entries
-            .iter()
-            .filter_map(|entry| match entry {
-                ListEntry::Thread(thread) if thread.is_live => {
-                    let sid = thread.metadata.session_id.clone()?;
-                    Some((sid, thread.status))
-                }
-                _ => None,
-            })
-            .collect();
+        let old_statuses = &self.live_thread_statuses;
 
         let mut entries = Vec::new();
         let mut notified_threads = previous.notified_threads;
         let mut notified_terminals: HashSet<TerminalId> = HashSet::new();
+        let mut new_live_statuses: HashMap<acp::SessionId, (AgentThreadStatus, ThreadId)> =
+            HashMap::new();
         let mut current_session_ids: HashSet<acp::SessionId> = HashSet::new();
         let mut current_thread_ids: HashSet<agent_ui::ThreadId> = HashSet::new();
         let mut current_terminal_ids: HashSet<TerminalId> = HashSet::new();
@@ -1566,9 +1564,12 @@ impl Sidebar {
                 // Merge live info into threads and update notification state
                 // in a single pass.
                 for thread in &mut threads {
-                    if let Some(session_id) = &thread.metadata.session_id {
-                        if let Some(info) = live_info_by_session.get(session_id) {
+                    if let Some(session_id) = thread.metadata.session_id.clone() {
+                        if let Some(&info) = live_info_by_session.get(&session_id) {
+                            let status = info.status;
+                            let thread_id = thread.metadata.thread_id;
                             thread.apply_active_info(info);
+                            new_live_statuses.insert(session_id, (status, thread_id));
                         }
                     }
 
@@ -1582,8 +1583,10 @@ impl Sidebar {
 
                     if thread.status == AgentThreadStatus::Completed
                         && !is_active_thread
-                        && session_id.as_ref().and_then(|sid| old_statuses.get(sid))
-                            == Some(&AgentThreadStatus::Running)
+                        && session_id
+                            .as_ref()
+                            .and_then(|sid| old_statuses.get(sid))
+                            .is_some_and(|(s, _)| *s == AgentThreadStatus::Running)
                     {
                         notified_threads.insert(thread.metadata.thread_id);
                     }
@@ -1599,13 +1602,35 @@ impl Sidebar {
                     b_time.cmp(&a_time)
                 });
             } else {
-                for info in live_infos {
+                for info in &live_infos {
                     if info.status == AgentThreadStatus::Running {
                         has_running_threads = true;
                     }
                     if info.status == AgentThreadStatus::WaitingForConfirmation {
                         waiting_thread_count += 1;
                     }
+                    // Resolve the thread_id for this session so we can
+                    // track its status and detect transitions even while
+                    // the group is collapsed.
+                    let thread_id = old_statuses
+                        .get(&info.session_id)
+                        .map(|(_, tid)| *tid)
+                        .or_else(|| {
+                            ThreadMetadataStore::global(cx)
+                                .read(cx)
+                                .entry_by_session(&info.session_id)
+                                .map(|m| m.thread_id)
+                        });
+
+                    if let Some(thread_id) = thread_id {
+                        let old_status = old_statuses.get(&info.session_id).map(|(s, _)| *s);
+                        new_live_statuses.insert(info.session_id.clone(), (info.status, thread_id));
+                        if info.status == AgentThreadStatus::Completed
+                            && old_status == Some(AgentThreadStatus::Running)
+                        {
+                            notified_threads.insert(thread_id);
+                        }
+                    }
                 }
             }
 
@@ -1698,6 +1723,14 @@ impl Sidebar {
                     continue;
                 }
 
+                // Check for notifications: threads that completed while not active.
+                let has_thread_notifications = matched_threads
+                    .iter()
+                    .any(|t| notified_threads.contains(&t.metadata.thread_id));
+                let has_terminal_notifications = matched_terminals
+                    .iter()
+                    .any(|t| notified_terminals.contains(&t.metadata.terminal_id));
+
                 project_header_indices.push(entries.len());
                 entries.push(ListEntry::ProjectHeader {
                     key: group_key.clone(),
@@ -1705,6 +1738,7 @@ impl Sidebar {
                     highlight_positions: workspace_highlight_positions,
                     has_running_threads,
                     waiting_thread_count,
+                    has_notifications: has_thread_notifications || has_terminal_notifications,
                     is_active,
                     has_threads,
                 });
@@ -1717,6 +1751,32 @@ impl Sidebar {
                     &mut current_thread_ids,
                 );
             } else {
+                let has_terminal_notifications = terminals
+                    .iter()
+                    .any(|t| notified_terminals.contains(&t.metadata.terminal_id));
+
+                // When collapsed, threads aren't loaded into `threads`, so we
+                // query the store for thread IDs to check notifications and
+                // to prevent the retain below from purging them.
+                let has_thread_notifications = if threads.is_empty() && !notified_threads.is_empty()
+                {
+                    let thread_store = ThreadMetadataStore::global(cx);
+                    let store = thread_store.read(cx);
+                    let group_thread_ids = store
+                        .entries_for_main_worktree_path(group_key.path_list(), group_host.as_ref())
+                        .chain(store.entries_for_path(group_key.path_list(), group_host.as_ref()))
+                        .map(|m| m.thread_id)
+                        .collect::<HashSet<_>>();
+                    current_thread_ids.extend(group_thread_ids.iter());
+                    group_thread_ids
+                        .iter()
+                        .any(|id| notified_threads.contains(id))
+                } else {
+                    threads
+                        .iter()
+                        .any(|t| notified_threads.contains(&t.metadata.thread_id))
+                };
+
                 project_header_indices.push(entries.len());
                 entries.push(ListEntry::ProjectHeader {
                     key: group_key.clone(),
@@ -1724,6 +1784,7 @@ impl Sidebar {
                     highlight_positions: Vec::new(),
                     has_running_threads,
                     waiting_thread_count,
+                    has_notifications: has_thread_notifications || has_terminal_notifications,
                     is_active,
                     has_threads,
                 });
@@ -1749,6 +1810,8 @@ impl Sidebar {
         self.terminal_last_accessed
             .retain(|id, _| current_terminal_ids.contains(id));
 
+        self.live_thread_statuses = new_live_statuses;
+
         self.contents = SidebarContents {
             entries,
             notified_threads,
@@ -1862,6 +1925,7 @@ impl Sidebar {
                 highlight_positions,
                 has_running_threads,
                 waiting_thread_count,
+                has_notifications,
                 is_active: is_active_group,
                 has_threads,
             } => {
@@ -1885,6 +1949,7 @@ impl Sidebar {
                     highlight_positions,
                     *has_running_threads,
                     *waiting_thread_count,
+                    *has_notifications,
                     *is_active_group,
                     is_selected,
                     *has_threads,
@@ -1943,6 +2008,7 @@ impl Sidebar {
         highlight_positions: &[usize],
         has_running_threads: bool,
         waiting_thread_count: usize,
+        has_notifications: bool,
         is_active: bool,
         is_focused: bool,
         has_threads: bool,
@@ -2054,6 +2120,16 @@ impl Sidebar {
                                     .tooltip(Tooltip::text(tooltip_text)),
                             )
                         })
+                        .when(
+                            has_notifications && !has_running_threads && waiting_thread_count == 0,
+                            |this| {
+                                this.child(
+                                    Icon::new(IconName::Circle)
+                                        .size(IconSize::Small)
+                                        .color(Color::Accent),
+                                )
+                            },
+                        )
                     })
                     .child(
                         div()
@@ -2509,6 +2585,7 @@ impl Sidebar {
             highlight_positions,
             has_running_threads,
             waiting_thread_count,
+            has_notifications,
             is_active,
             has_threads,
         } = self.contents.entries.get(header_idx)?
@@ -2538,6 +2615,7 @@ impl Sidebar {
             &highlight_positions,
             *has_running_threads,
             *waiting_thread_count,
+            *has_notifications,
             *is_active,
             is_selected,
             *has_threads,
diff --git a/crates/sidebar/src/sidebar_tests.rs b/crates/sidebar/src/sidebar_tests.rs
index c65eda086ab..a7a7263daa8 100644
--- a/crates/sidebar/src/sidebar_tests.rs
+++ b/crates/sidebar/src/sidebar_tests.rs
@@ -938,6 +938,7 @@ async fn test_visible_entries_as_strings(cx: &mut TestAppContext) {
                 highlight_positions: Vec::new(),
                 has_running_threads: false,
                 waiting_thread_count: 0,
+                has_notifications: false,
                 is_active: true,
                 has_threads: true,
             },
@@ -1084,6 +1085,7 @@ async fn test_visible_entries_as_strings(cx: &mut TestAppContext) {
                 highlight_positions: Vec::new(),
                 has_running_threads: false,
                 waiting_thread_count: 0,
+                has_notifications: false,
                 is_active: false,
                 has_threads: false,
             },

From d61ffb8e6b7ccaeb7bb1a5b2f4916ec650e51f76 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Thu, 21 May 2026 16:37:55 -0300
Subject: [PATCH 093/105] agent_ui: Add section for skills and rules in
 ellipsis menu (#57404)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closes AI-291

This PR adds some new menu items in the agent panel's ellipsis menu to
make it easier to 1) create a new skill, 2) manage all existing skills
through the settings window, 3) open project and global AGENTS.md file,
if it exists.

Minor UI note: I'm adding an ellipsis character to the menu items in
which you need to do something else in a different view to fulfill the
item's label. For example, "Create Skill…" takes the ellipsis because
clicking on the menu item itself doesn't create the skill, but it takes
you to the place where you'll do that.

<img width="600" alt="Screenshot 2026-05-21 at 10  32@2x"
src="https://github.com/user-attachments/assets/1bfdd423-bd75-4c62-97ba-84130035ede8"
/>

Release Notes:

- N/A
---
 crates/agent_ui/src/agent_panel.rs | 117 +++++++++++++++++++++++++----
 1 file changed, 104 insertions(+), 13 deletions(-)

diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs
index e52d0431bc2..f83025b7735 100644
--- a/crates/agent_ui/src/agent_panel.rs
+++ b/crates/agent_ui/src/agent_panel.rs
@@ -10,7 +10,7 @@ use std::{
 };
 
 use acp_thread::{AcpThread, AcpThreadEvent, MentionUri, ThreadStatus};
-use agent::{ContextServerRegistry, SharedThread, ThreadStore};
+use agent::{ContextServerRegistry, SharedThread, ThreadStore, UserAgentsMd};
 use agent_client_protocol::schema as acp;
 use agent_servers::AgentServer;
 use collections::HashSet;
@@ -4780,6 +4780,28 @@ impl AgentPanel {
             .active_conversation_view()
             .is_some_and(|conversation_view| conversation_view.read(cx).supports_logout(cx));
 
+        let project_agents_md_path: Option<PathBuf> = self
+            .project
+            .read(cx)
+            .visible_worktrees(cx)
+            .next()
+            .and_then(|worktree| {
+                let worktree = worktree.read(cx);
+                let rel_path = util::rel_path::RelPath::unix("AGENTS.md").ok()?;
+                let entry = worktree.entry_for_path(rel_path)?;
+                if entry.is_file() {
+                    Some(worktree.absolutize(rel_path))
+                } else {
+                    None
+                }
+            });
+
+        let global_agents_md_loaded = UserAgentsMd::global(cx)
+            .and_then(|md| md.content())
+            .is_some();
+
+        let workspace = self.workspace.clone();
+
         PopoverMenu::new("agent-options-menu")
             .trigger_with_tooltip(
                 IconButton::new("agent-options-menu", IconName::Ellipsis)
@@ -4821,8 +4843,9 @@ impl AgentPanel {
                         if !showing_terminal {
                             menu = menu
                                 .header("MCP Servers")
+                                .action("Add Custom Server…", Box::new(AddContextServer))
                                 .action(
-                                    "View Server Extensions",
+                                    "Install New Servers…",
                                     Box::new(zed_actions::Extensions {
                                         category_filter: Some(
                                             zed_actions::ExtensionCategoryFilter::ContextServers,
@@ -4830,16 +4853,81 @@ impl AgentPanel {
                                         id: None,
                                     }),
                                 )
-                                .action("Add Custom Server…", Box::new(AddContextServer))
+                                .separator()
+                                .header("Skills")
+                                .entry(
+                                    "Create Skill…",
+                                    Some(Box::new(OpenRulesLibrary::default())),
+                                    |window, cx| {
+                                        window.dispatch_action(Box::new(OpenSkillCreator), cx);
+                                    },
+                                )
+                                .entry("Manage Skills…", None, |window, cx| {
+                                    window.dispatch_action(
+                                        Box::new(zed_actions::OpenSettingsAt {
+                                            path: "agent.skills".to_string(),
+                                        }),
+                                        cx,
+                                    );
+                                })
                                 .separator();
 
-                            menu = menu.entry(
-                                "Skills",
-                                Some(Box::new(OpenRulesLibrary::default())),
-                                |window, cx| {
-                                    window.dispatch_action(Box::new(OpenSkillCreator), cx);
-                                },
-                            );
+                            if project_agents_md_path.is_some() || global_agents_md_loaded {
+                                menu = menu.header("Rules");
+
+                                if global_agents_md_loaded {
+                                    let workspace = workspace.clone();
+                                    menu = menu.entry(
+                                        "Open Global AGENTS.md",
+                                        None,
+                                        move |window, cx| {
+                                            workspace
+                                                .update(cx, |workspace, cx| {
+                                                    workspace
+                                                        .open_abs_path(
+                                                            paths::agents_file().clone(),
+                                                            workspace::OpenOptions {
+                                                                focus: Some(true),
+                                                                ..Default::default()
+                                                            },
+                                                            window,
+                                                            cx,
+                                                        )
+                                                        .detach_and_log_err(cx);
+                                                })
+                                                .log_err();
+                                        },
+                                    );
+                                }
+
+                                if let Some(path) = project_agents_md_path.clone() {
+                                    let workspace = workspace.clone();
+                                    menu = menu.entry(
+                                        "Open Project AGENTS.md",
+                                        None,
+                                        move |window, cx| {
+                                            let path = path.clone();
+                                            workspace
+                                                .update(cx, |workspace, cx| {
+                                                    workspace
+                                                        .open_abs_path(
+                                                            path,
+                                                            workspace::OpenOptions {
+                                                                focus: Some(true),
+                                                                ..Default::default()
+                                                            },
+                                                            window,
+                                                            cx,
+                                                        )
+                                                        .detach_and_log_err(cx);
+                                                })
+                                                .log_err();
+                                        },
+                                    );
+                                }
+
+                                menu = menu.separator();
+                            }
 
                             menu = menu.action("Profiles", Box::new(ManageProfiles::default()));
                         }
@@ -4849,6 +4937,9 @@ impl AgentPanel {
                             .separator()
                             .action("Toggle Threads Sidebar", Box::new(ToggleWorkspaceSidebar));
 
+                        if has_auth_methods || supports_logout {
+                            menu = menu.separator()
+                        }
                         if has_auth_methods {
                             menu = menu.action("Reauthenticate", Box::new(ReauthenticateAgent))
                         }
@@ -8173,12 +8264,12 @@ mod tests {
         cx.run_until_parked();
 
         assert!(
-            cx.debug_bounds("MENU_ITEM-Skills").is_some(),
-            "Skills menu item should be visible"
+            cx.debug_bounds("MENU_ITEM-Create Skill…").is_some(),
+            "Create Skill… menu item should be visible"
         );
         assert!(
             cx.debug_bounds("KEY_BINDING-l").is_some(),
-            "Skills menu item should show the OpenRulesLibrary shortcut"
+            "Create Skill… menu item should show the OpenRulesLibrary shortcut"
         );
     }
 

From f0cbb42fa6f3ad45b47d739bb50d79fc1e703f23 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Thu, 21 May 2026 16:48:43 -0300
Subject: [PATCH 094/105] recent_projects: Fix activation defaulting to main
 worktree (#57321)

Closes AI-280

When navigating between projects opened in the same window through the
recent projects picker, the confirm action would always default to
picking the main worktree in a project. So if you were in a Git worktree
in project A, switched to project B, and then back to project A, when
coming back, you wouldn't be in the Git worktree you were in before. The
fix is done through matching by project group key instead of file system
paths. Since both the main and linked worktrees share the same key, it
will just find the previously active workspace and activate it.

Release Notes:

- Fixed a bug where navigating through open projects in the same window
through the recent projects would always default to the main worktree of
a given project, instead of activating the last active
worktree/workspace.
---
 crates/recent_projects/src/recent_projects.rs | 43 +++++++++++++------
 1 file changed, 30 insertions(+), 13 deletions(-)

diff --git a/crates/recent_projects/src/recent_projects.rs b/crates/recent_projects/src/recent_projects.rs
index 7ed1db6bfc5..712dd34f353 100644
--- a/crates/recent_projects/src/recent_projects.rs
+++ b/crates/recent_projects/src/recent_projects.rs
@@ -1135,24 +1135,41 @@ impl PickerDelegate for RecentProjectsDelegate {
                 }
 
                 let key = key.clone();
-                let path_list = key.path_list().clone();
                 if let Some(handle) = window.window_handle().downcast::<MultiWorkspace>() {
                     cx.defer(move |cx| {
-                        if let Some(task) = handle
-                            .update(cx, |multi_workspace, window, cx| {
-                                multi_workspace.find_or_create_local_workspace(
-                                    path_list,
-                                    Some(key.clone()),
-                                    &[],
-                                    None,
-                                    OpenMode::Activate,
-                                    window,
-                                    cx,
-                                )
+                        // Try to activate an existing workspace for this project group
+                        // first, so we preserve the actual worktree paths (which may
+                        // differ from the main git worktree paths stored in the key).
+                        if let Some(workspace) = handle
+                            .update(cx, |multi_workspace, _window, cx| {
+                                multi_workspace.last_active_workspace_for_group(&key, cx)
                             })
                             .log_err()
+                            .flatten()
                         {
-                            task.detach_and_log_err(cx);
+                            handle
+                                .update(cx, |multi_workspace, window, cx| {
+                                    multi_workspace.activate(workspace, None, window, cx);
+                                })
+                                .log_err();
+                        } else {
+                            let path_list = key.path_list().clone();
+                            if let Some(task) = handle
+                                .update(cx, |multi_workspace, window, cx| {
+                                    multi_workspace.find_or_create_local_workspace(
+                                        path_list,
+                                        Some(key.clone()),
+                                        &[],
+                                        None,
+                                        OpenMode::Activate,
+                                        window,
+                                        cx,
+                                    )
+                                })
+                                .log_err()
+                            {
+                                task.detach_and_log_err(cx);
+                            }
                         }
                     });
                 }

From 139954071524f166762db38bcfb5381931f62b86 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Thu, 21 May 2026 16:48:51 -0300
Subject: [PATCH 095/105] settings_ui: Display scope in the breadcrumb (#57437)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Whenever there are subpages in the settings UI, a breadcrumb is
displayed. However, we weren't displaying the scope as part of the
breadcrumb, which can be relevant if you're wondering why a certain
information you expected to see here isn't being displayed. It might
just be that it is displayed in the _project_ scope instead of in the
_user_ scope. Therefore, this PR adds the scope in the breadcrumb:

| Before | After |
|--------|--------|
| <img width="1348" height="290" alt="Screenshot 2026-05-21 at 4  38
2@2x"
src="https://github.com/user-attachments/assets/1b64ba98-8e7e-41a7-9b13-19722bdbe093"
/> | <img width="1348" height="290" alt="Screenshot 2026-05-21 at 4 
38@2x"
src="https://github.com/user-attachments/assets/b5deb091-0617-42ac-bb4a-b8ba00ec386c"
/> |

Release Notes:

- Started to display the setting scope (user or project) in the Settings
Editor for better contextualization of settings subpages.
---
 crates/settings_ui/src/settings_ui.rs | 29 +++++++++++++++++----------
 1 file changed, 18 insertions(+), 11 deletions(-)

diff --git a/crates/settings_ui/src/settings_ui.rs b/crates/settings_ui/src/settings_ui.rs
index 5f9d323746e..08ac192c88b 100644
--- a/crates/settings_ui/src/settings_ui.rs
+++ b/crates/settings_ui/src/settings_ui.rs
@@ -3006,19 +3006,26 @@ impl SettingsWindow {
     }
 
     fn render_sub_page_breadcrumbs(&self) -> impl IntoElement {
+        let scope_name: SharedString = self
+            .display_name(&self.current_file)
+            .unwrap_or_else(|| self.current_file.setting_type().to_string())
+            .into();
+
         h_flex().min_w_0().gap_1().overflow_x_hidden().children(
             itertools::intersperse(
-                std::iter::once(self.current_page().title.into()).chain(
-                    self.sub_page_stack
-                        .iter()
-                        .enumerate()
-                        .flat_map(|(index, page)| {
-                            (index == 0)
-                                .then(|| page.section_header.clone())
-                                .into_iter()
-                                .chain(std::iter::once(page.link.title.clone()))
-                        }),
-                ),
+                std::iter::once(scope_name)
+                    .chain(std::iter::once(self.current_page().title.into()))
+                    .chain(
+                        self.sub_page_stack
+                            .iter()
+                            .enumerate()
+                            .flat_map(|(index, page)| {
+                                (index == 0)
+                                    .then(|| page.section_header.clone())
+                                    .into_iter()
+                                    .chain(std::iter::once(page.link.title.clone()))
+                            }),
+                    ),
                 "/".into(),
             )
             .map(|item| Label::new(item).color(Color::Muted)),

From 77cbba9b1a32cda8151a41572890e48afef72b0c Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Thu, 21 May 2026 18:56:35 -0300
Subject: [PATCH 096/105] sidebar: Add ability to move projects up and down
 (#57448)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closes AI-298

This PR adds the first step towards allowing to reorganize the threads
sidebar. Drag and drop should be supported in the near future, maybe
even replacing this entirely:

<img width="700" alt="Screenshot 2026-05-21 at 6  44@2x"
src="https://github.com/user-attachments/assets/db420466-2323-474b-ba41-17eb4da2cf84"
/>

Release Notes:

- Sidebar: Added the ability to reorder projects by moving them up and
down through the ellipsis menu.
---
 crates/sidebar/src/sidebar.rs           | 81 ++++++++++++++++++++-----
 crates/workspace/src/multi_workspace.rs | 40 ++++++++++++
 2 files changed, 106 insertions(+), 15 deletions(-)

diff --git a/crates/sidebar/src/sidebar.rs b/crates/sidebar/src/sidebar.rs
index 78c941aa399..b02beeeee0b 100644
--- a/crates/sidebar/src/sidebar.rs
+++ b/crates/sidebar/src/sidebar.rs
@@ -50,10 +50,10 @@ use std::rc::Rc;
 use std::sync::Arc;
 use theme::ActiveTheme;
 use ui::{
-    AgentThreadStatus, CommonAnimationExt, ContextMenu, Divider, GradientFade, HighlightedLabel,
-    KeyBinding, PopoverMenu, PopoverMenuHandle, ProjectEmptyState, ScrollAxes, Scrollbars, Tab,
-    ThreadItem, ThreadItemWorktreeInfo, TintColor, Tooltip, WithScrollbar, prelude::*,
-    render_modifiers,
+    AgentThreadStatus, CommonAnimationExt, ContextMenu, ContextMenuEntry, Divider, GradientFade,
+    HighlightedLabel, KeyBinding, PopoverMenu, PopoverMenuHandle, ProjectEmptyState, ScrollAxes,
+    Scrollbars, Tab, ThreadItem, ThreadItemWorktreeInfo, TintColor, Tooltip, WithScrollbar,
+    prelude::*, render_modifiers,
 };
 use util::ResultExt as _;
 use util::path_list::PathList;
@@ -2302,6 +2302,19 @@ impl Sidebar {
                     })
                     .unwrap_or_default();
 
+                // Compute reorder state at menu-open time so it reflects the
+                // most recent group ordering.
+                let (group_index, total_groups) = multi_workspace
+                    .read_with(cx, |mw, _| {
+                        let keys = mw.project_group_keys();
+                        let index = keys.iter().position(|k| k == &project_group_key);
+                        (index, keys.len())
+                    })
+                    .unwrap_or((None, 0));
+                let show_reorder_entries = total_groups >= 2;
+                let can_move_up = group_index.is_some_and(|i| i > 0);
+                let can_move_down = group_index.is_some_and(|i| i + 1 < total_groups);
+
                 let active_workspace = multi_workspace
                     .read_with(cx, |multi_workspace, _cx| {
                         multi_workspace.workspace().clone()
@@ -2521,19 +2534,57 @@ impl Sidebar {
                             menu
                         };
 
+                        let menu = menu.when(show_reorder_entries, |this| {
+                            let move_up_multi_workspace = multi_workspace.clone();
+                            let move_up_key = project_group_key.clone();
+                            let move_up_weak_menu = weak_menu.clone();
+                            let move_down_multi_workspace = multi_workspace.clone();
+                            let move_down_key = project_group_key.clone();
+                            let move_down_weak_menu = weak_menu.clone();
+
+                            this.separator()
+                                .item(
+                                    ContextMenuEntry::new("Move Up")
+                                        .disabled(!can_move_up)
+                                        .handler(move |_window, cx| {
+                                            move_up_multi_workspace
+                                                .update(cx, |mw, cx| {
+                                                    mw.move_project_group_up(&move_up_key, cx);
+                                                })
+                                                .ok();
+                                            move_up_weak_menu
+                                                .update(cx, |_, cx| cx.emit(DismissEvent))
+                                                .ok();
+                                        }),
+                                )
+                                .item(
+                                    ContextMenuEntry::new("Move Down")
+                                        .disabled(!can_move_down)
+                                        .handler(move |_window, cx| {
+                                            move_down_multi_workspace
+                                                .update(cx, |mw, cx| {
+                                                    mw.move_project_group_down(&move_down_key, cx);
+                                                })
+                                                .ok();
+                                            move_down_weak_menu
+                                                .update(cx, |_, cx| cx.emit(DismissEvent))
+                                                .ok();
+                                        }),
+                                )
+                        });
+
                         let project_group_key = project_group_key.clone();
                         let remove_multi_workspace = multi_workspace.clone();
-                        menu.separator()
-                            .entry("Remove Project", None, move |window, cx| {
-                                remove_multi_workspace
-                                    .update(cx, |multi_workspace, cx| {
-                                        multi_workspace
-                                            .remove_project_group(&project_group_key, window, cx)
-                                            .detach_and_log_err(cx);
-                                    })
-                                    .ok();
-                                weak_menu.update(cx, |_, cx| cx.emit(DismissEvent)).ok();
-                            })
+                        menu.separator().entry("Remove", None, move |window, cx| {
+                            remove_multi_workspace
+                                .update(cx, |multi_workspace, cx| {
+                                    multi_workspace
+                                        .remove_project_group(&project_group_key, window, cx)
+                                        .detach_and_log_err(cx);
+                                })
+                                .ok();
+                            weak_menu.update(cx, |_, cx| cx.emit(DismissEvent)).ok();
+                        })
                     });
 
                 let this = this.clone();
diff --git a/crates/workspace/src/multi_workspace.rs b/crates/workspace/src/multi_workspace.rs
index b4ba998c771..61344668eb2 100644
--- a/crates/workspace/src/multi_workspace.rs
+++ b/crates/workspace/src/multi_workspace.rs
@@ -852,6 +852,46 @@ impl MultiWorkspace {
         }
     }
 
+    pub fn move_project_group_up(&mut self, key: &ProjectGroupKey, cx: &mut Context<Self>) -> bool {
+        let Some(index) = self
+            .project_groups
+            .iter()
+            .position(|group| group.key == *key)
+        else {
+            return false;
+        };
+        if index == 0 {
+            return false;
+        }
+        self.project_groups.swap(index - 1, index);
+        cx.emit(MultiWorkspaceEvent::ProjectGroupsChanged);
+        self.serialize(cx);
+        cx.notify();
+        true
+    }
+
+    pub fn move_project_group_down(
+        &mut self,
+        key: &ProjectGroupKey,
+        cx: &mut Context<Self>,
+    ) -> bool {
+        let Some(index) = self
+            .project_groups
+            .iter()
+            .position(|group| group.key == *key)
+        else {
+            return false;
+        };
+        if index + 1 >= self.project_groups.len() {
+            return false;
+        }
+        self.project_groups.swap(index, index + 1);
+        cx.emit(MultiWorkspaceEvent::ProjectGroupsChanged);
+        self.serialize(cx);
+        cx.notify();
+        true
+    }
+
     pub fn workspaces_for_project_group(
         &self,
         key: &ProjectGroupKey,

From f78f6da255afe353fa2b726addca578dbcfd78c8 Mon Sep 17 00:00:00 2001
From: MartinYe1234 <52641447+MartinYe1234@users.noreply.github.com>
Date: Thu, 21 May 2026 15:04:32 -0700
Subject: [PATCH 097/105] Make file paths in backticks clickable in agent panel
 (#57303)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When the agent mentions a file path inside `backticks` (e.g. ``
`src/main.rs` `` or `` `src/main.rs:42` ``), the rendered code span now
becomes a clickable link in the agent panel. Clicking opens the
referenced file in the workspace, jumping to the right line and column
when present.

## How it works

- **Shared path resolution.** Extracted `OpenTarget` and the
workspace/worktree resolution logic out of
`terminal_view::terminal_path_like_target` into a new
`workspace::path_link` module so both the terminal and the agent panel
can use the same code. Includes a `sanitize_path_text` helper ported
from the terminal's URL/punctuation handling. Pure refactor — terminal
behavior is unchanged.
- **`markdown` crate hook.** Added
`MarkdownElement::on_code_span_link(callback)`. When the callback
returns `Some(url)` for a given code span's contents, the existing
`push_link` machinery wires up cmd-hover, hit testing, and the existing
`on_url_click` callback. When it returns `None`, the code span renders
as before. The hook is opt-in, so `markdown` stays workspace-agnostic.
- **Agent panel wiring.** `render_agent_markdown` constructs an
`AgentCodeSpanResolver` that snapshots the project's visible worktree
entries plus their file extensions. `try_resolve` does a cheap
synchronous heuristic check (path must contain `/`/`\` or end in an
extension present in the workspace, can't be a URL, can't be all digits,
etc.) and then looks the candidate up in the per-worktree
`HashSet<Arc<RelPath>>`. On a hit it returns a `MentionUri::File` or
`MentionUri::Selection` URI, which the existing `thread_view::open_link`
already knows how to open at the right line.

## Edge cases handled

- Code spans inside fenced code blocks stay plain (gated on
`builder.code_block_stack.is_empty()`, matching how regular markdown
links behave).
- Trailing prose punctuation (`` `src/main.rs.` ``) is stripped before
lookup.
- Identifiers like `` `String` ``, `` `await` ``, `` `npm run dev` ``
stay plain — they don't pass the path-like heuristic.
- Cross-platform path separators handled via the per-worktree
`PathStyle`.

## Tests

- `crates/markdown` — unit test asserting code spans become links when
the callback returns `Some`, and stay plain when it doesn't.
- `crates/agent_ui` — unit test for `AgentCodeSpanResolver::try_resolve`
covering hits with and without a `:line` suffix, misses, identifiers,
and trailing punctuation.
- Existing `terminal_view` tests cover the moved resolution code
(unchanged behavior).

## Notes

- There's currently a temporary `log::info!` in
`AgentCodeSpanResolver::try_resolve` that reports per-call worktree-walk
timing and a cumulative total. Kept in for now to verify the feature
isn't being called excessively during streaming renders. Can be removed
before merge.
- Resolution is sync-only against worktree entries; absolute paths
outside the workspace are not resolved (would require an async re-render
path).

Closes AI-277

Release Notes:

- Made file paths in `backticks` clickable in the agent panel; clicking
opens the referenced file at the given line when present.
---
 Cargo.lock                                    |   2 +
 Cargo.toml                                    |   1 +
 crates/acp_thread/src/mention.rs              |  77 +++-
 crates/agent_ui/Cargo.toml                    |   1 +
 crates/agent_ui/src/agent_ui.rs               |  41 +-
 crates/agent_ui/src/conversation_view.rs      | 299 ++++++++++++-
 .../src/conversation_view/thread_view.rs      |  78 ++--
 crates/agent_ui/src/mention_set.rs            |   3 +
 crates/agent_ui/src/message_editor.rs         |   5 +
 crates/agent_ui/src/ui/mention_crease.rs      |  62 +--
 crates/markdown/src/markdown.rs               | 150 ++++++-
 .../src/terminal_path_like_target.rs          | 402 ++---------------
 crates/workspace/Cargo.toml                   |   1 +
 crates/workspace/src/path_link.rs             | 422 ++++++++++++++++++
 crates/workspace/src/workspace.rs             |   1 +
 15 files changed, 1096 insertions(+), 449 deletions(-)
 create mode 100644 crates/workspace/src/path_link.rs

diff --git a/Cargo.lock b/Cargo.lock
index 2ccdca4d6cc..43c2b961b86 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -407,6 +407,7 @@ dependencies = [
  "language_models",
  "languages",
  "log",
+ "lru",
  "lsp",
  "markdown",
  "menu",
@@ -22018,6 +22019,7 @@ dependencies = [
  "collections",
  "component",
  "db",
+ "dirs",
  "fs",
  "futures 0.3.32",
  "futures-lite 1.13.0",
diff --git a/Cargo.toml b/Cargo.toml
index e936bea3d71..6db9f292287 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -622,6 +622,7 @@ linkify = "0.10.0"
 libwebrtc = "0.3.26"
 livekit = { version = "0.7.32", features = ["tokio", "rustls-tls-native-roots"] }
 log = { version = "0.4.16", features = ["kv_unstable_serde", "serde"] }
+lru = "0.16"
 lsp-types = { git = "https://github.com/zed-industries/lsp-types", rev = "f4dfa89a21ca35cd929b70354b1583fabae325f8" }
 mach2 = "0.5"
 markup5ever_rcdom = "0.3.0"
diff --git a/crates/acp_thread/src/mention.rs b/crates/acp_thread/src/mention.rs
index 12827acc833..cb96de34813 100644
--- a/crates/acp_thread/src/mention.rs
+++ b/crates/acp_thread/src/mention.rs
@@ -51,6 +51,8 @@ pub enum MentionUri {
         #[serde(default, skip_serializing_if = "Option::is_none")]
         abs_path: Option<PathBuf>,
         line_range: RangeInclusive<u32>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        column: Option<u32>,
     },
     Fetch {
         url: Url,
@@ -105,6 +107,17 @@ impl MentionUri {
             Ok(start_line..=end_line)
         }
 
+        let parse_column =
+            |input: Option<String>| -> Option<u32> { input?.parse::<u32>().ok()?.checked_sub(1) };
+        let validate_query_params = |url: &Url, allowed: &[&str]| -> Result<()> {
+            for (key, _) in url.query_pairs() {
+                if !allowed.contains(&key.as_ref()) {
+                    bail!("invalid query parameter")
+                }
+            }
+            Ok(())
+        };
+
         let parse_absolute_path = |input: &str| -> Result<Self> {
             let (path_input, fragment) = input
                 .split_once('#')
@@ -114,6 +127,7 @@ impl MentionUri {
                 return Ok(MentionUri::Selection {
                     abs_path: Some(path_input.into()),
                     line_range: fragment,
+                    column: None,
                 });
             }
 
@@ -123,10 +137,12 @@ impl MentionUri {
                 let line = row
                     .checked_sub(1)
                     .context("Line numbers should be 1-based")?;
-                // TODO: Preserve column info too.
                 Ok(MentionUri::Selection {
                     abs_path: Some(abs_path),
                     line_range: line..=line,
+                    column: path_with_position
+                        .column
+                        .map(|column| column.saturating_sub(1)),
                 })
             } else {
                 Ok(MentionUri::File { abs_path })
@@ -156,8 +172,10 @@ impl MentionUri {
                 let path = normalized.as_ref();
 
                 if let Some(fragment) = url.fragment() {
+                    validate_query_params(&url, &["symbol", "column"])?;
                     let line_range = parse_line_range(fragment).log_err().unwrap_or(1..=1);
-                    if let Some(name) = single_query_param(&url, "symbol")? {
+                    let column = parse_column(query_param(&url, "column"));
+                    if let Some(name) = query_param(&url, "symbol") {
                         Ok(Self::Symbol {
                             name,
                             abs_path: path.into(),
@@ -167,6 +185,7 @@ impl MentionUri {
                         Ok(Self::Selection {
                             abs_path: Some(path.into()),
                             line_range,
+                            column,
                         })
                     }
                 } else if input.ends_with("/") {
@@ -216,9 +235,11 @@ impl MentionUri {
                         .fragment()
                         .context("Missing fragment for untitled buffer selection")?;
                     let line_range = parse_line_range(fragment)?;
+                    validate_query_params(&url, &["column"])?;
                     Ok(Self::Selection {
                         abs_path: None,
                         line_range,
+                        column: parse_column(query_param(&url, "column")),
                     })
                 } else if let Some(name) = path.strip_prefix("/agent/symbol/") {
                     let fragment = url
@@ -245,13 +266,15 @@ impl MentionUri {
                         abs_path: path.into(),
                     })
                 } else if path.starts_with("/agent/selection") {
+                    validate_query_params(&url, &["path", "column"])?;
                     let fragment = url.fragment().context("Missing fragment for selection")?;
                     let line_range = parse_line_range(fragment)?;
-                    let path =
-                        single_query_param(&url, "path")?.context("Missing path for selection")?;
+                    let column = parse_column(query_param(&url, "column"));
+                    let path = query_param(&url, "path").context("Missing path for selection")?;
                     Ok(Self::Selection {
                         abs_path: Some(path.into()),
                         line_range,
+                        column,
                     })
                 } else if path.starts_with("/agent/terminal-selection") {
                     let line_count = single_query_param(&url, "lines")?
@@ -460,6 +483,7 @@ impl MentionUri {
                 abs_path,
                 name,
                 line_range,
+                ..
             } => {
                 let mut url = Url::parse("file:///").unwrap();
                 url.set_path(&abs_path.to_string_lossy());
@@ -474,6 +498,7 @@ impl MentionUri {
             MentionUri::Selection {
                 abs_path,
                 line_range,
+                column,
             } => {
                 let mut url = if let Some(path) = abs_path {
                     let mut url = Url::parse("file:///").unwrap();
@@ -484,6 +509,10 @@ impl MentionUri {
                     url.set_path("/agent/untitled-buffer");
                     url
                 };
+                if let Some(column) = column {
+                    url.query_pairs_mut()
+                        .append_pair("column", &(column + 1).to_string());
+                }
                 url.set_fragment(Some(&format!(
                     "L{}:{}",
                     line_range.start() + 1,
@@ -564,6 +593,11 @@ fn default_include_errors() -> bool {
     true
 }
 
+fn query_param(url: &Url, name: &'static str) -> Option<String> {
+    url.query_pairs()
+        .find_map(|(key, value)| (key == name).then(|| value.to_string()))
+}
+
 fn single_query_param(url: &Url, name: &'static str) -> Result<Option<String>> {
     let pairs = url.query_pairs().collect::<Vec<_>>();
     match pairs.as_slice() {
@@ -698,6 +732,7 @@ mod tests {
                 abs_path: path,
                 name,
                 line_range,
+                ..
             } => {
                 assert_eq!(path, Path::new(path!("/path/to/file.rs")));
                 assert_eq!(name, "MySymbol");
@@ -717,6 +752,7 @@ mod tests {
             MentionUri::Selection {
                 abs_path: path,
                 line_range,
+                ..
             } => {
                 assert_eq!(path.as_ref().unwrap(), Path::new(path!("/path/to/file.rs")));
                 assert_eq!(line_range.start(), &4);
@@ -748,6 +784,7 @@ mod tests {
             MentionUri::Selection {
                 abs_path: None,
                 line_range,
+                ..
             } => {
                 assert_eq!(line_range.start(), &0);
                 assert_eq!(line_range.end(), &9);
@@ -895,6 +932,7 @@ mod tests {
             MentionUri::Selection {
                 abs_path: path,
                 line_range,
+                ..
             } => {
                 assert_eq!(path.as_ref().unwrap(), Path::new("/path/to/file.rs"));
                 assert_eq!(line_range.start(), &41);
@@ -904,6 +942,29 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_parse_absolute_file_path_with_row_and_column() {
+        let file_path = "/path/to/file.rs:42:5";
+        let parsed = MentionUri::parse(file_path, PathStyle::Posix).unwrap();
+        match &parsed {
+            MentionUri::Selection {
+                abs_path: path,
+                line_range,
+                column,
+            } => {
+                assert_eq!(path.as_ref().unwrap(), Path::new("/path/to/file.rs"));
+                assert_eq!(line_range.start(), &41);
+                assert_eq!(line_range.end(), &41);
+                assert_eq!(column, &Some(4));
+
+                let parsed_again = MentionUri::parse(parsed.to_uri().as_ref(), PathStyle::Posix)
+                    .expect("selection URI with column should parse");
+                assert_eq!(parsed_again, parsed.clone());
+            }
+            _ => panic!("Expected Selection variant"),
+        }
+    }
+
     #[test]
     fn test_parse_absolute_file_path_with_fragment_line() {
         let file_path = "/path/to/file.rs#L42";
@@ -912,6 +973,7 @@ mod tests {
             MentionUri::Selection {
                 abs_path: path,
                 line_range,
+                ..
             } => {
                 assert_eq!(path.as_ref().unwrap(), Path::new("/path/to/file.rs"));
                 assert_eq!(line_range.start(), &41);
@@ -941,6 +1003,7 @@ mod tests {
             MentionUri::Selection {
                 abs_path: path,
                 line_range,
+                ..
             } => {
                 assert_eq!(
                     path.as_ref().unwrap(),
@@ -961,6 +1024,7 @@ mod tests {
             MentionUri::Selection {
                 abs_path: path,
                 line_range,
+                ..
             } => {
                 assert_eq!(
                     path.as_ref().unwrap(),
@@ -993,6 +1057,7 @@ mod tests {
             MentionUri::Selection {
                 abs_path: path,
                 line_range,
+                ..
             } => {
                 assert_eq!(path.as_ref().unwrap(), Path::new("/path/to/file.rs"));
                 assert_eq!(line_range.start(), &41);
@@ -1010,6 +1075,7 @@ mod tests {
             MentionUri::Selection {
                 abs_path: path,
                 line_range,
+                ..
             } => {
                 assert_eq!(
                     path.as_ref().unwrap(),
@@ -1031,6 +1097,7 @@ mod tests {
             MentionUri::Selection {
                 abs_path: path,
                 line_range,
+                ..
             } => {
                 assert_eq!(path.as_ref().unwrap(), Path::new(path!("/path/to/file.rs")));
                 assert_eq!(line_range.start(), &1871);
@@ -1048,6 +1115,7 @@ mod tests {
             MentionUri::Selection {
                 abs_path: path,
                 line_range,
+                ..
             } => {
                 assert_eq!(path.as_ref().unwrap(), Path::new(path!("/path/to/file.rs")));
                 assert_eq!(line_range.start(), &9);
@@ -1063,6 +1131,7 @@ mod tests {
             MentionUri::Selection {
                 abs_path: path,
                 line_range,
+                ..
             } => {
                 assert_eq!(path.as_ref().unwrap(), Path::new(path!("/path/to/file.rs")));
                 assert_eq!(line_range.start(), &9);
diff --git a/crates/agent_ui/Cargo.toml b/crates/agent_ui/Cargo.toml
index 91c0f21a51f..68b0b5faa41 100644
--- a/crates/agent_ui/Cargo.toml
+++ b/crates/agent_ui/Cargo.toml
@@ -69,6 +69,7 @@ language.workspace = true
 language_model.workspace = true
 language_models.workspace = true
 log.workspace = true
+lru.workspace = true
 lsp.workspace = true
 markdown.workspace = true
 menu.workspace = true
diff --git a/crates/agent_ui/src/agent_ui.rs b/crates/agent_ui/src/agent_ui.rs
index c9063378d89..209976c090a 100644
--- a/crates/agent_ui/src/agent_ui.rs
+++ b/crates/agent_ui/src/agent_ui.rs
@@ -43,10 +43,12 @@ use ::ui::IconName;
 use agent_client_protocol::schema as acp;
 use agent_settings::{AgentProfileId, AgentSettings};
 use command_palette_hooks::CommandPaletteFilter;
+use editor::{Editor, SelectionEffects, scroll::Autoscroll};
 use feature_flags::FeatureFlagAppExt as _;
 use fs::Fs;
 use gpui::{
-    Action, App, Context, Entity, ImageSource, Resource, SharedString, SharedUri, Window, actions,
+    Action, App, Context, Entity, ImageSource, Resource, SharedString, SharedUri, TaskExt, Window,
+    actions,
 };
 use language::{
     LanguageRegistry,
@@ -57,6 +59,7 @@ use language_model::{
 };
 use project::{AgentId, DisableAiSettings};
 use prompt_store::{PromptBuilder, rules_to_skills_migration};
+use rope::Point;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{LanguageModelSelection, Settings as _, SettingsStore, SidebarSide};
@@ -112,6 +115,42 @@ pub(crate) fn resolve_agent_image(
     None
 }
 
+pub(crate) fn open_abs_path_at_point(
+    workspace: &mut Workspace,
+    abs_path: PathBuf,
+    point: Point,
+    window: &mut Window,
+    cx: &mut Context<Workspace>,
+) -> bool {
+    let project = workspace.project();
+    let Some(path) = project.update(cx, |project, cx| project.find_project_path(abs_path, cx))
+    else {
+        return false;
+    };
+
+    let item = workspace.open_path(path, None, true, window, cx);
+    window
+        .spawn(cx, async move |cx| {
+            let Some(editor) = item.await?.downcast::<Editor>() else {
+                return Ok(());
+            };
+            let range = point..point;
+            editor
+                .update_in(cx, |editor, window, cx| {
+                    editor.change_selections(
+                        SelectionEffects::scroll(Autoscroll::center()),
+                        window,
+                        cx,
+                        |selections| selections.select_ranges([range]),
+                    );
+                })
+                .ok();
+            anyhow::Ok(())
+        })
+        .detach_and_log_err(cx);
+    true
+}
+
 pub const DEFAULT_THREAD_TITLE: &str = "New Agent Thread";
 const PARALLEL_AGENT_LAYOUT_BACKFILL_KEY: &str = "parallel_agent_layout_backfilled";
 
diff --git a/crates/agent_ui/src/conversation_view.rs b/crates/agent_ui/src/conversation_view.rs
index b8e72840be6..3ef7e111fe6 100644
--- a/crates/agent_ui/src/conversation_view.rs
+++ b/crates/agent_ui/src/conversation_view.rs
@@ -40,14 +40,16 @@ use language_model::{LanguageModelCompletionError, LanguageModelRegistry};
 use markdown::{
     CodeBlockRenderer, CopyButtonVisibility, Markdown, MarkdownElement, MarkdownFont, MarkdownStyle,
 };
-use parking_lot::RwLock;
-use project::{AgentId, AgentServerStore, Project, ProjectEntryId};
+use parking_lot::{Mutex, RwLock};
+use project::{AgentId, AgentServerStore, Project, ProjectEntryId, ProjectPath};
 use prompt_store::{PromptId, PromptStore};
 
 use crate::message_editor::SessionCapabilities;
 use crate::{AgentThreadSource, DEFAULT_THREAD_TITLE, resolve_agent_image};
+use lru::LruCache;
 use rope::Point;
 use settings::{NotifyWhenAgentWaiting, Settings as _, SettingsStore, ThinkingBlockDisplay};
+use std::num::NonZeroUsize;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::time::Instant;
@@ -61,11 +63,17 @@ use ui::{
     KeyBinding, PopoverMenu, PopoverMenuHandle, TintColor, Tooltip, WithScrollbar, prelude::*,
     right_click_menu,
 };
-use util::{ResultExt, size::format_file_size, time::duration_alt_display};
-use util::{debug_panic, defer};
+use util::{
+    ResultExt, debug_panic, defer,
+    paths::{PathStyle, PathWithPosition},
+    rel_path::RelPath,
+    size::format_file_size,
+    time::duration_alt_display,
+};
 use workspace::PathList;
 use workspace::{
     CollaboratorId, MultiWorkspace, NewTerminal, Toast, Workspace, notifications::NotificationId,
+    path_link::sanitize_path_text,
 };
 use zed_actions::agent::{Chat, ToggleModelSelector};
 use zed_actions::assistant::OpenRulesLibrary;
@@ -509,6 +517,9 @@ pub struct ConversationView {
     /// causes mermaid diagrams to re-render).
     last_theme_id: Option<String>,
     draft_prompt_persist_task: Option<Task<()>>,
+    /// Cache + worktree snapshot for resolving paths in markdown code spans.
+    /// Shared with the child [`ThreadView`] when one is constructed.
+    pub(crate) code_span_resolver: AgentCodeSpanResolver,
     _subscriptions: Vec<Subscription>,
 }
 
@@ -707,7 +718,8 @@ impl ConversationView {
         cx: &mut Context<Self>,
     ) -> Self {
         let agent_server_store = project.read(cx).agent_server_store().clone();
-        let subscriptions = vec![
+        let code_span_resolver = AgentCodeSpanResolver::new(&project.downgrade(), cx);
+        let mut subscriptions = vec![
             cx.observe_global_in::<SettingsStore>(window, Self::agent_ui_font_size_changed),
             cx.observe_global_in::<SettingsStore>(window, Self::invalidate_mermaid_caches),
             cx.observe_global_in::<AgentUiFontSize>(window, Self::agent_ui_font_size_changed),
@@ -718,6 +730,20 @@ impl ConversationView {
                 Self::handle_agent_servers_updated,
             ),
         ];
+        subscriptions.push(cx.subscribe(&project, {
+            let resolver = code_span_resolver.clone();
+            move |_this: &mut Self, _project, event: &project::Event, cx| {
+                if matches!(
+                    event,
+                    project::Event::WorktreeAdded(_)
+                        | project::Event::WorktreeRemoved(_)
+                        | project::Event::WorktreeUpdatedEntries(_, _)
+                ) {
+                    resolver.clear_cache();
+                    cx.notify();
+                }
+            }
+        }));
 
         cx.on_release(|this, cx| {
             if let Some(connected) = this.as_connected() {
@@ -764,6 +790,7 @@ impl ConversationView {
             auth_task: None,
             last_theme_id: Some(cx.theme().id.clone()),
             draft_prompt_persist_task: None,
+            code_span_resolver,
             _subscriptions: subscriptions,
             focus_handle: cx.focus_handle(),
         }
@@ -1218,6 +1245,7 @@ impl ConversationView {
                 session_capabilities,
                 resumed_without_history,
                 self.project.downgrade(),
+                self.code_span_resolver.clone(),
                 self.thread_store.clone(),
                 self.prompt_store.clone(),
                 initial_content,
@@ -2511,7 +2539,7 @@ impl ConversationView {
             markdown,
             style,
             &self.workspace,
-            &self.project.downgrade(),
+            &self.code_span_resolver,
             cx,
         )
     }
@@ -3118,20 +3146,12 @@ fn render_agent_markdown(
     markdown: Entity<Markdown>,
     style: MarkdownStyle,
     workspace: &WeakEntity<Workspace>,
-    project: &WeakEntity<Project>,
+    code_span_resolver: &AgentCodeSpanResolver,
     cx: &App,
 ) -> MarkdownElement {
     let workspace = workspace.clone();
-    let worktree_roots: Vec<PathBuf> = project
-        .upgrade()
-        .map(|project| {
-            project
-                .read(cx)
-                .visible_worktrees(cx)
-                .map(|worktree| worktree.read(cx).abs_path().to_path_buf())
-                .collect()
-        })
-        .unwrap_or_default();
+    let worktree_roots = code_span_resolver.worktree_roots(cx);
+    let resolver = code_span_resolver.clone();
     MarkdownElement::new(markdown, style)
         .code_block_renderer(markdown::CodeBlockRenderer::Default {
             copy_button_visibility: markdown::CopyButtonVisibility::VisibleOnHover,
@@ -3142,6 +3162,175 @@ fn render_agent_markdown(
         .on_url_click(move |text, window, cx| {
             thread_view::open_link(text, &workspace, window, cx);
         })
+        .on_code_span_link(move |text, cx| resolver.try_resolve(text, cx))
+}
+
+/// Shared, cloneable handle for resolving inline markdown code spans like
+/// `` `src/main.rs:42` `` to clickable workspace file links.
+#[derive(Clone)]
+pub(crate) struct AgentCodeSpanResolver {
+    inner: Arc<AgentCodeSpanResolverInner>,
+}
+
+/// Maximum number of memoized code-span resolutions kept in the cache.
+const CODE_SPAN_CACHE_CAPACITY: NonZeroUsize = match NonZeroUsize::new(2048) {
+    Some(n) => n,
+    None => unreachable!(),
+};
+
+struct AgentCodeSpanResolverInner {
+    project: WeakEntity<Project>,
+    cache: Mutex<LruCache<Arc<str>, Option<SharedString>>>,
+}
+
+impl AgentCodeSpanResolver {
+    pub(crate) fn new(project: &WeakEntity<Project>, _cx: &App) -> Self {
+        Self {
+            inner: Arc::new(AgentCodeSpanResolverInner {
+                project: project.clone(),
+                cache: Mutex::new(LruCache::new(CODE_SPAN_CACHE_CAPACITY)),
+            }),
+        }
+    }
+
+    pub(crate) fn clear_cache(&self) {
+        self.inner.cache.lock().clear();
+    }
+
+    /// Absolute paths of every current worktree.
+    /// Used by the markdown image resolver, which needs the same set of roots.
+    fn worktree_roots(&self, cx: &App) -> Vec<PathBuf> {
+        self.inner
+            .project
+            .upgrade()
+            .map(|project| {
+                project
+                    .read(cx)
+                    .visible_worktrees(cx)
+                    .map(|worktree| worktree.read(cx).abs_path().to_path_buf())
+                    .collect()
+            })
+            .unwrap_or_default()
+    }
+
+    fn try_resolve(&self, text: &str, cx: &App) -> Option<SharedString> {
+        let trimmed = sanitize_path_text(text.trim());
+        if !Self::is_path_like(trimmed) {
+            return None;
+        }
+
+        if let Some(cached) = self.inner.cache.lock().get(trimmed).cloned() {
+            return cached;
+        }
+
+        let resolved = self.resolve_uncached(trimmed, cx);
+        self.inner
+            .cache
+            .lock()
+            .push(Arc::from(trimmed), resolved.clone());
+        resolved
+    }
+
+    fn resolve_uncached(&self, trimmed: &str, cx: &App) -> Option<SharedString> {
+        let path_with_position = PathWithPosition::parse_str(trimmed);
+        let candidate_path = &path_with_position.path;
+        if candidate_path.as_os_str().is_empty() {
+            return None;
+        }
+
+        let project = self.inner.project.upgrade()?;
+        let project = project.read(cx);
+        for worktree in project.visible_worktrees(cx) {
+            let worktree = worktree.read(cx);
+            for relative_path in Self::candidate_relative_paths(
+                candidate_path,
+                &worktree.abs_path(),
+                worktree.path_style(),
+            ) {
+                let project_path = ProjectPath {
+                    worktree_id: worktree.id(),
+                    path: relative_path.clone(),
+                };
+                let Some(entry) = project.entry_for_path(&project_path, cx) else {
+                    continue;
+                };
+                if !entry.is_file() {
+                    continue;
+                }
+
+                let abs_path = worktree.absolutize(&relative_path);
+                let mention = match path_with_position.row.and_then(|row| row.checked_sub(1)) {
+                    Some(line) => MentionUri::Selection {
+                        abs_path: Some(abs_path),
+                        line_range: line..=line,
+                        column: path_with_position
+                            .column
+                            .map(|column| column.saturating_sub(1)),
+                    },
+                    None => MentionUri::File { abs_path },
+                };
+
+                return Some(mention.to_uri().to_string().into());
+            }
+        }
+
+        None
+    }
+
+    fn candidate_relative_paths(
+        path: &Path,
+        worktree_abs_path: &Path,
+        path_style: PathStyle,
+    ) -> Vec<Arc<RelPath>> {
+        let path_text = path.to_string_lossy();
+        let relative_path: Option<Arc<RelPath>> =
+            if util::paths::is_absolute(path_text.as_ref(), path_style) {
+                path_style
+                    .strip_prefix(path, worktree_abs_path)
+                    .map(std::borrow::Cow::into_owned)
+                    .map(Into::into)
+            } else {
+                RelPath::new(path, path_style)
+                    .ok()
+                    .map(std::borrow::Cow::into_owned)
+                    .map(Into::into)
+            };
+
+        let Some(relative_path) = relative_path else {
+            return Vec::new();
+        };
+
+        let mut paths = vec![relative_path.clone()];
+        if let Some(root_name) = worktree_abs_path.file_name().and_then(|name| name.to_str())
+            && let Ok(root_name) = RelPath::new(Path::new(root_name), path_style)
+            && let Ok(stripped) = relative_path.strip_prefix(root_name.as_ref())
+            && !stripped.is_empty()
+        {
+            paths.push(Arc::from(stripped));
+        }
+        paths
+    }
+
+    fn is_path_like(text: &str) -> bool {
+        if text.len() < 3
+            || text.contains("://")
+            || text.contains('|')
+            || text.chars().any(char::is_control)
+            || text.chars().all(|character| character.is_ascii_digit())
+        {
+            return false;
+        }
+
+        let path = PathWithPosition::parse_str(text).path;
+        let path_text = path.to_string_lossy();
+        if path_text.contains('/') || path_text.contains('\\') {
+            return true;
+        }
+
+        path.extension()
+            .and_then(|extension| extension.to_str())
+            .is_some_and(|extension| !extension.is_empty())
+    }
 }
 
 fn plan_label_markdown_style(
@@ -3256,6 +3445,82 @@ pub(crate) mod tests {
         });
     }
 
+    #[gpui::test]
+    async fn test_agent_code_span_resolver_resolves_worktree_paths(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(
+            util::path!("/project"),
+            json!({
+                "src": {
+                    "main.rs": ""
+                },
+                "README.md": ""
+            }),
+        )
+        .await;
+
+        let project = Project::test(fs, [Path::new(util::path!("/project"))], cx).await;
+        let resolver = cx.update(|cx| AgentCodeSpanResolver::new(&project.downgrade(), cx));
+
+        let uri = cx
+            .update(|cx| resolver.try_resolve("src/main.rs:10", cx))
+            .expect("expected worktree-relative file path to resolve");
+        assert_eq!(
+            MentionUri::parse(&uri, PathStyle::local()).unwrap(),
+            MentionUri::Selection {
+                abs_path: Some(PathBuf::from(util::path!("/project/src/main.rs"))),
+                line_range: 9..=9,
+                column: None,
+            }
+        );
+
+        let uri = cx
+            .update(|cx| resolver.try_resolve("src/main.rs:10:5", cx))
+            .expect("expected worktree-relative file path with row and column to resolve");
+        assert_eq!(
+            MentionUri::parse(&uri, PathStyle::local()).unwrap(),
+            MentionUri::Selection {
+                abs_path: Some(PathBuf::from(util::path!("/project/src/main.rs"))),
+                line_range: 9..=9,
+                column: Some(4),
+            }
+        );
+
+        let uri = cx
+            .update(|cx| resolver.try_resolve("src/main.rs:0", cx))
+            .expect("`:0` should fall back to a file mention instead of returning None");
+        assert_eq!(
+            MentionUri::parse(&uri, PathStyle::local()).unwrap(),
+            MentionUri::File {
+                abs_path: PathBuf::from(util::path!("/project/src/main.rs")),
+            }
+        );
+
+        assert!(cx.update(|cx| resolver.try_resolve("String", cx)).is_none());
+        assert!(
+            cx.update(|cx| resolver.try_resolve("does/not/exist.rs", cx))
+                .is_none()
+        );
+        assert!(
+            cx.update(|cx| resolver.try_resolve("src/main.rs.", cx))
+                .is_some()
+        );
+
+        let uri = cx
+            .update(|cx| resolver.try_resolve("project/src/main.rs:10", cx))
+            .expect("expected root-prefixed worktree path to resolve");
+        assert_eq!(
+            MentionUri::parse(&uri, PathStyle::local()).unwrap(),
+            MentionUri::Selection {
+                abs_path: Some(PathBuf::from(util::path!("/project/src/main.rs"))),
+                line_range: 9..=9,
+                column: None,
+            }
+        );
+    }
+
     #[gpui::test]
     async fn test_notification_for_stop_event(cx: &mut TestAppContext) {
         init_test(cx);
diff --git a/crates/agent_ui/src/conversation_view/thread_view.rs b/crates/agent_ui/src/conversation_view/thread_view.rs
index 3b0c0dd37cc..43d850f8688 100644
--- a/crates/agent_ui/src/conversation_view/thread_view.rs
+++ b/crates/agent_ui/src/conversation_view/thread_view.rs
@@ -1,6 +1,7 @@
 use crate::{
     DEFAULT_THREAD_TITLE, SelectPermissionGranularity,
     agent_configuration::configure_context_server_modal::default_markdown_style,
+    open_abs_path_at_point,
     thread_metadata_store::{ThreadId, ThreadMetadataStore},
 };
 use agent_client_protocol::schema as acp;
@@ -330,6 +331,10 @@ pub struct ThreadView {
     pub add_context_menu_handle: PopoverMenuHandle<ContextMenu>,
     pub thinking_effort_menu_handle: PopoverMenuHandle<ContextMenu>,
     pub project: WeakEntity<Project>,
+    /// Cache + worktree snapshot for resolving paths in markdown code spans.
+    /// Cloned from the parent `ConversationView` so the cache is shared and the
+    /// snapshot stays in sync via the parent's project-event subscription.
+    pub(crate) code_span_resolver: AgentCodeSpanResolver,
     pub show_external_source_prompt_warning: bool,
     pub show_codex_windows_warning: bool,
     pub multi_root_callout_dismissed: bool,
@@ -382,6 +387,7 @@ impl ThreadView {
         session_capabilities: SharedSessionCapabilities,
         resumed_without_history: bool,
         project: WeakEntity<Project>,
+        code_span_resolver: AgentCodeSpanResolver,
         thread_store: Option<Entity<ThreadStore>>,
         prompt_store: Option<Entity<PromptStore>>,
         initial_content: Option<AgentInitialContent>,
@@ -449,6 +455,23 @@ impl ThreadView {
             && project.upgrade().is_some_and(|p| p.read(cx).is_local())
             && agent_id.as_ref() == "Codex";
 
+        if let Some(project) = project.upgrade() {
+            subscriptions.push(cx.subscribe(&project, {
+                let resolver = code_span_resolver.clone();
+                move |_this: &mut Self, _project, event: &project::Event, cx| {
+                    if matches!(
+                        event,
+                        project::Event::WorktreeAdded(_)
+                            | project::Event::WorktreeRemoved(_)
+                            | project::Event::WorktreeUpdatedEntries(_, _)
+                    ) {
+                        resolver.clear_cache();
+                        cx.notify();
+                    }
+                }
+            }));
+        }
+
         let title_editor = {
             let metadata = ThreadMetadataStore::try_global(cx)
                 .and_then(|store| store.read(cx).entry(root_thread_id).cloned());
@@ -601,6 +624,7 @@ impl ThreadView {
             add_context_menu_handle: PopoverMenuHandle::default(),
             thinking_effort_menu_handle: PopoverMenuHandle::default(),
             project,
+            code_span_resolver,
             show_external_source_prompt_warning,
             show_codex_windows_warning,
             multi_root_callout_dismissed: false,
@@ -8701,7 +8725,13 @@ impl ThreadView {
         style: MarkdownStyle,
         cx: &App,
     ) -> MarkdownElement {
-        render_agent_markdown(markdown, style, &self.workspace, &self.project, cx)
+        render_agent_markdown(
+            markdown,
+            style,
+            &self.workspace,
+            &self.code_span_resolver,
+            cx,
+        )
     }
 
     fn create_copy_button(&self, message: impl Into<String>) -> impl IntoElement {
@@ -9372,39 +9402,27 @@ pub(crate) fn open_link(
                 abs_path: path,
                 line_range,
                 ..
+            } => {
+                open_abs_path_at_point(
+                    workspace,
+                    path,
+                    Point::new(*line_range.start(), 0),
+                    window,
+                    cx,
+                );
             }
-            | MentionUri::Selection {
+            MentionUri::Selection {
                 abs_path: Some(path),
                 line_range,
+                column,
             } => {
-                let project = workspace.project();
-                let Some(path) =
-                    project.update(cx, |project, cx| project.find_project_path(path, cx))
-                else {
-                    return;
-                };
-
-                let item = workspace.open_path(path, None, true, window, cx);
-                window
-                    .spawn(cx, async move |cx| {
-                        let Some(editor) = item.await?.downcast::<Editor>() else {
-                            return Ok(());
-                        };
-                        let range =
-                            Point::new(*line_range.start(), 0)..Point::new(*line_range.start(), 0);
-                        editor
-                            .update_in(cx, |editor, window, cx| {
-                                editor.change_selections(
-                                    SelectionEffects::scroll(Autoscroll::center()),
-                                    window,
-                                    cx,
-                                    |s| s.select_ranges(vec![range]),
-                                );
-                            })
-                            .ok();
-                        anyhow::Ok(())
-                    })
-                    .detach_and_log_err(cx);
+                open_abs_path_at_point(
+                    workspace,
+                    path,
+                    Point::new(*line_range.start(), column.unwrap_or(0)),
+                    window,
+                    cx,
+                );
             }
             MentionUri::Selection { abs_path: None, .. } => {}
             MentionUri::Thread { id, name } => {
diff --git a/crates/agent_ui/src/mention_set.rs b/crates/agent_ui/src/mention_set.rs
index d1335d31811..beecb840f08 100644
--- a/crates/agent_ui/src/mention_set.rs
+++ b/crates/agent_ui/src/mention_set.rs
@@ -167,6 +167,7 @@ impl MentionSet {
             MentionUri::Selection {
                 abs_path: Some(abs_path),
                 line_range,
+                ..
             } => self.confirm_mention_for_symbol(abs_path, line_range, cx),
             MentionUri::Selection { abs_path: None, .. } => Task::ready(Err(anyhow!(
                 "Untitled buffer selection mentions are not supported for paste"
@@ -570,6 +571,7 @@ impl MentionSet {
             let uri = MentionUri::Selection {
                 abs_path: abs_path.clone(),
                 line_range: line_range.clone(),
+                column: None,
             };
             let crease = crease_for_mention(
                 selection_name(abs_path.as_deref(), &line_range).into(),
@@ -805,6 +807,7 @@ mod tests {
                 MentionUri::Selection {
                     abs_path: Some(path!("/project/file.rs").into()),
                     line_range: 1..=2,
+                    column: None,
                 },
                 false,
                 http_client,
diff --git a/crates/agent_ui/src/message_editor.rs b/crates/agent_ui/src/message_editor.rs
index 90cbdffb6db..5b6b8671413 100644
--- a/crates/agent_ui/src/message_editor.rs
+++ b/crates/agent_ui/src/message_editor.rs
@@ -1119,6 +1119,7 @@ impl MessageEditor {
                     let mention_uri = MentionUri::Selection {
                         abs_path: Some(file_path.clone()),
                         line_range: line_range.clone(),
+                        column: None,
                     };
 
                     let mention_text = mention_uri.as_link().to_string();
@@ -4397,10 +4398,12 @@ mod tests {
         let first_uri = MentionUri::Selection {
             abs_path: Some(path!("/project/file.rs").into()),
             line_range: 0..=1,
+            column: None,
         };
         let second_uri = MentionUri::Selection {
             abs_path: Some(path!("/project/file.rs").into()),
             line_range: 2..=3,
+            column: None,
         };
 
         source_message_editor.update_in(&mut cx, |message_editor, window, cx| {
@@ -4558,10 +4561,12 @@ mod tests {
         let first_uri = MentionUri::Selection {
             abs_path: Some(path!("/project/file.rs").into()),
             line_range: 0..=1,
+            column: None,
         };
         let second_uri = MentionUri::Selection {
             abs_path: Some(path!("/project/file.rs").into()),
             line_range: 2..=3,
+            column: None,
         };
 
         let buffer_len = message_editor.update_in(&mut cx, |message_editor, window, cx| {
diff --git a/crates/agent_ui/src/ui/mention_crease.rs b/crates/agent_ui/src/ui/mention_crease.rs
index 41e3d5cef5d..6ce10698b5f 100644
--- a/crates/agent_ui/src/ui/mention_crease.rs
+++ b/crates/agent_ui/src/ui/mention_crease.rs
@@ -1,8 +1,8 @@
-use std::{ops::RangeInclusive, path::PathBuf, time::Duration};
+use std::{path::PathBuf, time::Duration};
 
 use acp_thread::MentionUri;
 use agent_client_protocol::schema as acp;
-use editor::{Editor, SelectionEffects, scroll::Autoscroll};
+use editor::Editor;
 use gpui::{
     Animation, AnimationExt, AnyView, Context, IntoElement, TaskExt, WeakEntity, Window,
     pulsating_between,
@@ -15,6 +15,8 @@ use theme_settings::ThemeSettings;
 use ui::{ButtonLike, TintColor, Tooltip, prelude::*};
 use workspace::{OpenOptions, Workspace};
 
+use crate::open_abs_path_at_point;
+
 #[derive(IntoElement)]
 pub struct MentionCrease {
     id: ElementId,
@@ -165,12 +167,27 @@ fn open_mention_uri(
             abs_path,
             line_range,
             ..
+        } => {
+            open_file(
+                workspace,
+                abs_path,
+                Some(Point::new(*line_range.start(), 0)),
+                window,
+                cx,
+            );
         }
-        | MentionUri::Selection {
+        MentionUri::Selection {
             abs_path: Some(abs_path),
             line_range,
+            column,
         } => {
-            open_file(workspace, abs_path, Some(line_range), window, cx);
+            open_file(
+                workspace,
+                abs_path,
+                Some(Point::new(*line_range.start(), column.unwrap_or(0))),
+                window,
+                cx,
+            );
         }
         MentionUri::Directory { abs_path } => {
             reveal_in_project_panel(workspace, abs_path, cx);
@@ -260,40 +277,23 @@ fn open_skill_file(
 fn open_file(
     workspace: &mut Workspace,
     abs_path: PathBuf,
-    line_range: Option<RangeInclusive<u32>>,
+    point: Option<Point>,
     window: &mut Window,
     cx: &mut Context<Workspace>,
 ) {
-    let project = workspace.project();
+    if let Some(point) = point {
+        if open_abs_path_at_point(workspace, abs_path.clone(), point, window, cx) {
+            return;
+        }
+    }
 
+    let project = workspace.project();
     if let Some(project_path) =
         project.update(cx, |project, cx| project.find_project_path(&abs_path, cx))
     {
-        let item = workspace.open_path(project_path, None, true, window, cx);
-        if let Some(line_range) = line_range {
-            window
-                .spawn(cx, async move |cx| {
-                    let Some(editor) = item.await?.downcast::<Editor>() else {
-                        return Ok(());
-                    };
-                    editor
-                        .update_in(cx, |editor, window, cx| {
-                            let range = Point::new(*line_range.start(), 0)
-                                ..Point::new(*line_range.start(), 0);
-                            editor.change_selections(
-                                SelectionEffects::scroll(Autoscroll::center()),
-                                window,
-                                cx,
-                                |selections| selections.select_ranges(vec![range]),
-                            );
-                        })
-                        .ok();
-                    anyhow::Ok(())
-                })
-                .detach_and_log_err(cx);
-        } else {
-            item.detach_and_log_err(cx);
-        }
+        workspace
+            .open_path(project_path, None, true, window, cx)
+            .detach_and_log_err(cx);
     } else if abs_path.exists() {
         workspace
             .open_abs_path(
diff --git a/crates/markdown/src/markdown.rs b/crates/markdown/src/markdown.rs
index f8ca35d7225..4abce8a878f 100644
--- a/crates/markdown/src/markdown.rs
+++ b/crates/markdown/src/markdown.rs
@@ -53,6 +53,7 @@ use crate::parser::CodeBlockKind;
 /// A callback function that can be used to customize the style of links based on the destination URL.
 /// If the callback returns `None`, the default link style will be used.
 type LinkStyleCallback = Rc<dyn Fn(&str, &App) -> Option<TextStyleRefinement>>;
+pub type CodeSpanLinkCallback = Arc<dyn Fn(&str, &App) -> Option<SharedString> + 'static>;
 type SourceClickCallback = Box<dyn Fn(usize, usize, &mut Window, &mut App) -> bool>;
 type CheckboxToggleCallback = Rc<dyn Fn(Range<usize>, bool, &mut Window, &mut App)>;
 
@@ -1079,6 +1080,7 @@ pub struct MarkdownElement {
     style: MarkdownStyle,
     code_block_renderer: CodeBlockRenderer,
     on_url_click: Option<Box<dyn Fn(SharedString, &mut Window, &mut App)>>,
+    code_span_link: Option<CodeSpanLinkCallback>,
     on_source_click: Option<SourceClickCallback>,
     on_checkbox_toggle: Option<CheckboxToggleCallback>,
     image_resolver: Option<Box<dyn Fn(&str) -> Option<ImageSource>>>,
@@ -1097,6 +1099,7 @@ impl MarkdownElement {
                 border: false,
             },
             on_url_click: None,
+            code_span_link: None,
             on_source_click: None,
             on_checkbox_toggle: None,
             image_resolver: None,
@@ -1139,6 +1142,14 @@ impl MarkdownElement {
         self
     }
 
+    pub fn on_code_span_link(
+        mut self,
+        callback: impl Fn(&str, &App) -> Option<SharedString> + 'static,
+    ) -> Self {
+        self.code_span_link = Some(Arc::new(callback));
+        self
+    }
+
     pub fn on_source_click(
         mut self,
         handler: impl Fn(usize, usize, &mut Window, &mut App) -> bool + 'static,
@@ -1173,6 +1184,41 @@ impl MarkdownElement {
         self
     }
 
+    fn push_markdown_code_span(
+        &self,
+        builder: &mut MarkdownElementBuilder,
+        text: &str,
+        range: Range<usize>,
+        cx: &App,
+    ) {
+        let link_url = if builder.code_block_stack.is_empty() && builder.link_depth == 0 {
+            self.code_span_link
+                .as_ref()
+                .and_then(|callback| callback(text, cx))
+        } else {
+            None
+        };
+
+        if let Some(url) = link_url {
+            builder.push_link(url.clone(), range.clone());
+            let link_style = self
+                .style
+                .link_callback
+                .as_ref()
+                .and_then(|callback| callback(url.as_ref(), cx))
+                .unwrap_or_else(|| self.style.link.clone());
+            builder.push_text_style(self.style.inline_code.clone());
+            builder.push_text_style(link_style);
+            builder.push_text(text, range);
+            builder.pop_text_style();
+            builder.pop_text_style();
+        } else {
+            builder.push_text_style(self.style.inline_code.clone());
+            builder.push_text(text, range);
+            builder.pop_text_style();
+        }
+    }
+
     fn push_markdown_image(
         &self,
         builder: &mut MarkdownElementBuilder,
@@ -2013,6 +2059,7 @@ impl Element for MarkdownElement {
                         }
                         MarkdownTag::Link { dest_url, .. } => {
                             if builder.code_block_stack.is_empty() {
+                                builder.link_depth += 1;
                                 builder.push_link(dest_url.clone(), range.clone());
                                 let style = self
                                     .style
@@ -2239,6 +2286,7 @@ impl Element for MarkdownElement {
                     MarkdownTagEnd::Strikethrough => builder.pop_text_style(),
                     MarkdownTagEnd::Link => {
                         if builder.code_block_stack.is_empty() {
+                            builder.link_depth = builder.link_depth.saturating_sub(1);
                             builder.pop_text_style()
                         }
                     }
@@ -2273,9 +2321,12 @@ impl Element for MarkdownElement {
                     builder.push_text(text, range.clone());
                 }
                 MarkdownEvent::Code => {
-                    builder.push_text_style(self.style.inline_code.clone());
-                    builder.push_text(&parsed_markdown.source[range.clone()], range.clone());
-                    builder.pop_text_style();
+                    self.push_markdown_code_span(
+                        &mut builder,
+                        &parsed_markdown.source[range.clone()],
+                        range.clone(),
+                        cx,
+                    );
                 }
                 MarkdownEvent::Html => {
                     let html = &parsed_markdown.source[range.clone()];
@@ -2293,6 +2344,19 @@ impl Element for MarkdownElement {
                 }
                 MarkdownEvent::InlineHtml => {
                     let html = &parsed_markdown.source[range.clone()];
+                    if let Some(code) = html
+                        .strip_prefix("<code>")
+                        .and_then(|html| html.strip_suffix("</code>"))
+                    {
+                        let code_start = range.start + "<code>".len();
+                        self.push_markdown_code_span(
+                            &mut builder,
+                            code,
+                            code_start..code_start + code.len(),
+                            cx,
+                        );
+                        continue;
+                    }
                     if html.starts_with("<code>") {
                         builder.push_text_style(self.style.inline_code.clone());
                         continue;
@@ -2653,6 +2717,7 @@ struct MarkdownElementBuilder {
     base_text_style: TextStyle,
     text_style_stack: Vec<TextStyleRefinement>,
     code_block_stack: Vec<Option<Arc<Language>>>,
+    link_depth: usize,
     list_stack: Vec<ListStackEntry>,
     table: TableState,
     syntax_theme: Arc<SyntaxTheme>,
@@ -2691,6 +2756,7 @@ impl MarkdownElementBuilder {
             base_text_style,
             text_style_stack: Vec::new(),
             code_block_stack: Vec::new(),
+            link_depth: 0,
             list_stack: Vec::new(),
             table: TableState::default(),
             syntax_theme,
@@ -3470,6 +3536,40 @@ mod tests {
         render_markdown_with_language_registry(markdown, None, cx)
     }
 
+    fn render_markdown_with_code_span_link(
+        markdown: &str,
+        callback: impl Fn(&str, &App) -> Option<SharedString> + 'static,
+        cx: &mut TestAppContext,
+    ) -> RenderedText {
+        struct TestWindow;
+
+        impl Render for TestWindow {
+            fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
+                div()
+            }
+        }
+
+        ensure_theme_initialized(cx);
+
+        let (_, cx) = cx.add_window_view(|_, _| TestWindow);
+        let markdown = cx.new(|cx| Markdown::new(markdown.to_string().into(), None, None, cx));
+        cx.run_until_parked();
+        let (rendered, _) = cx.draw(
+            Default::default(),
+            size(px(600.0), px(600.0)),
+            |_window, _cx| {
+                MarkdownElement::new(markdown, MarkdownStyle::default())
+                    .on_code_span_link(callback)
+                    .code_block_renderer(CodeBlockRenderer::Default {
+                        copy_button_visibility: CopyButtonVisibility::Hidden,
+                        wrap_button_visibility: WrapButtonVisibility::Hidden,
+                        border: false,
+                    })
+            },
+        );
+        rendered.text
+    }
+
     fn render_markdown_with_language_registry(
         markdown: &str,
         language_registry: Option<Arc<LanguageRegistry>>,
@@ -4105,6 +4205,50 @@ mod tests {
         assert!(rendered.link_for_source_index(5).is_none());
     }
 
+    #[gpui::test]
+    fn test_code_span_link_detected_for_source_index(cx: &mut TestAppContext) {
+        let source = "see `foo.rs` for details";
+        let rendered = render_markdown_with_code_span_link(
+            source,
+            |text, _cx| (text == "foo.rs").then(|| "file:///tmp/foo.rs".into()),
+            cx,
+        );
+
+        assert_eq!(rendered.links.len(), 1);
+        assert_eq!(rendered.links[0].destination_url, "file:///tmp/foo.rs");
+
+        let code_index = source.find("foo.rs").unwrap();
+        let link = rendered.link_for_source_index(code_index);
+        assert!(link.is_some());
+        assert_eq!(link.unwrap().destination_url, "file:///tmp/foo.rs");
+
+        assert!(
+            rendered
+                .link_for_source_index(source.find("see").unwrap())
+                .is_none()
+        );
+    }
+
+    #[gpui::test]
+    fn test_code_span_link_ignores_code_without_callback(cx: &mut TestAppContext) {
+        let rendered = render_markdown("see `foo.rs` for details", cx);
+
+        assert!(rendered.links.is_empty());
+    }
+
+    #[gpui::test]
+    fn test_code_span_link_ignores_code_inside_markdown_link(cx: &mut TestAppContext) {
+        let source = "see [`foo.rs`](https://example.com) for details";
+        let rendered = render_markdown_with_code_span_link(
+            source,
+            |text, _cx| (text == "foo.rs").then(|| "file:///tmp/foo.rs".into()),
+            cx,
+        );
+
+        assert_eq!(rendered.links.len(), 1);
+        assert_eq!(rendered.links[0].destination_url, "https://example.com");
+    }
+
     #[gpui::test]
     fn test_context_menu_link_initial_state(cx: &mut TestAppContext) {
         struct TestWindow;
diff --git a/crates/terminal_view/src/terminal_path_like_target.rs b/crates/terminal_view/src/terminal_path_like_target.rs
index fb3abf41db7..e6e6e94bffc 100644
--- a/crates/terminal_view/src/terminal_path_like_target.rs
+++ b/crates/terminal_view/src/terminal_path_like_target.rs
@@ -1,71 +1,17 @@
 use super::{HoverTarget, HoveredWord, TerminalView};
 use anyhow::{Context as _, Result};
 use editor::Editor;
-use gpui::{App, AppContext, Context, Task, TaskExt, WeakEntity, Window};
-use itertools::Itertools;
-use project::{Entry, Metadata};
+use gpui::{Context, Task, TaskExt, WeakEntity, Window};
 use std::path::PathBuf;
 use terminal::PathLikeTarget;
-use util::{
-    ResultExt, debug_panic,
-    paths::{PathStyle, PathWithPosition, normalize_lexically},
-    rel_path::RelPath,
+use util::{ResultExt, debug_panic};
+#[cfg(not(test))]
+use workspace::path_link::possible_open_target;
+#[cfg(test)]
+use workspace::path_link::{
+    BackgroundFsChecks, OpenTargetFoundBy, possible_open_target_with_fs_checks,
 };
-use workspace::{OpenOptions, OpenVisible, Workspace};
-
-/// The way we found the open target. This is important to have for test assertions.
-/// For example, remote projects never look in the file system.
-#[cfg(test)]
-#[derive(Debug, Clone, Copy, Eq, PartialEq)]
-enum OpenTargetFoundBy {
-    WorktreeExact,
-    WorktreeScan,
-    FileSystemBackground,
-}
-
-#[cfg(test)]
-#[derive(Debug, Clone, Copy, Eq, PartialEq)]
-enum BackgroundFsChecks {
-    Enabled,
-    Disabled,
-}
-
-#[derive(Debug, Clone)]
-enum OpenTarget {
-    Worktree(PathWithPosition, Entry, #[cfg(test)] OpenTargetFoundBy),
-    File(PathWithPosition, Metadata),
-}
-
-impl OpenTarget {
-    fn is_file(&self) -> bool {
-        match self {
-            OpenTarget::Worktree(_, entry, ..) => entry.is_file(),
-            OpenTarget::File(_, metadata) => !metadata.is_dir,
-        }
-    }
-
-    fn is_dir(&self) -> bool {
-        match self {
-            OpenTarget::Worktree(_, entry, ..) => entry.is_dir(),
-            OpenTarget::File(_, metadata) => metadata.is_dir,
-        }
-    }
-
-    fn path(&self) -> &PathWithPosition {
-        match self {
-            OpenTarget::Worktree(path, ..) => path,
-            OpenTarget::File(path, _) => path,
-        }
-    }
-
-    #[cfg(test)]
-    fn found_by(&self) -> OpenTargetFoundBy {
-        match self {
-            OpenTarget::Worktree(.., found_by) => *found_by,
-            OpenTarget::File(..) => OpenTargetFoundBy::FileSystemBackground,
-        }
-    }
-}
+use workspace::{OpenOptions, OpenVisible, Workspace, path_link::OpenTarget};
 
 pub(super) fn hover_path_like_target(
     workspace: &WeakEntity<Workspace>,
@@ -96,11 +42,19 @@ fn possible_hover_target(
     cx: &mut Context<TerminalView>,
     #[cfg(test)] background_fs_checks: BackgroundFsChecks,
 ) -> Task<()> {
+    #[cfg(not(test))]
     let file_to_open_task = possible_open_target(
         workspace,
-        path_like_target,
+        &path_like_target.maybe_path,
+        path_like_target.terminal_dir.as_deref(),
+        cx,
+    );
+    #[cfg(test)]
+    let file_to_open_task = possible_open_target_with_fs_checks(
+        workspace,
+        &path_like_target.maybe_path,
+        path_like_target.terminal_dir.as_deref(),
         cx,
-        #[cfg(test)]
         background_fs_checks,
     );
     cx.spawn(async move |terminal_view, cx| {
@@ -122,297 +76,6 @@ fn possible_hover_target(
     })
 }
 
-fn possible_open_target(
-    workspace: &WeakEntity<Workspace>,
-    path_like_target: &PathLikeTarget,
-    cx: &App,
-    #[cfg(test)] background_fs_checks: BackgroundFsChecks,
-) -> Task<Option<OpenTarget>> {
-    let Some(workspace) = workspace.upgrade() else {
-        return Task::ready(None);
-    };
-    // We have to check for both paths, as on Unix, certain paths with positions are valid file paths too.
-    // We can be on FS remote part, without real FS, so cannot canonicalize or check for existence the path right away.
-    let mut potential_paths = Vec::new();
-    let cwd = path_like_target.terminal_dir.as_ref();
-    let maybe_path = &path_like_target.maybe_path;
-    let original_path = PathWithPosition::from_path(PathBuf::from(maybe_path));
-    let path_with_position = PathWithPosition::parse_str(maybe_path);
-    let worktree_candidates = workspace
-        .read(cx)
-        .worktrees(cx)
-        .sorted_by_key(|worktree| {
-            let worktree_root = worktree.read(cx).abs_path();
-            match cwd.and_then(|cwd| worktree_root.strip_prefix(cwd).ok()) {
-                Some(cwd_child) => cwd_child.components().count(),
-                None => usize::MAX,
-            }
-        })
-        .collect::<Vec<_>>();
-    // Since we do not check paths via FS and joining, we need to strip off potential `./`, `a/`, `b/` prefixes out of it.
-    const GIT_DIFF_PATH_PREFIXES: &[&str] = &["a", "b"];
-    for prefix_str in GIT_DIFF_PATH_PREFIXES.iter().chain(std::iter::once(&".")) {
-        if let Some(stripped) = original_path.path.strip_prefix(prefix_str).ok() {
-            potential_paths.push(PathWithPosition {
-                path: stripped.to_owned(),
-                row: original_path.row,
-                column: original_path.column,
-            });
-        }
-        if let Some(stripped) = path_with_position.path.strip_prefix(prefix_str).ok() {
-            potential_paths.push(PathWithPosition {
-                path: stripped.to_owned(),
-                row: path_with_position.row,
-                column: path_with_position.column,
-            });
-        }
-    }
-
-    let insert_both_paths = original_path != path_with_position;
-    potential_paths.insert(0, original_path);
-    if insert_both_paths {
-        potential_paths.insert(1, path_with_position);
-    }
-
-    // If we won't find paths "easily", we can traverse the entire worktree to look what ends with the potential path suffix.
-    // That will be slow, though, so do the fast checks first.
-    let mut worktree_paths_to_check = Vec::new();
-    let mut is_cwd_in_worktree = false;
-    let mut open_target = None;
-    'worktree_loop: for worktree in &worktree_candidates {
-        let worktree_root = worktree.read(cx).abs_path();
-        let mut paths_to_check = Vec::with_capacity(potential_paths.len());
-        let relative_cwd = cwd
-            .and_then(|cwd| cwd.strip_prefix(&worktree_root).ok())
-            .and_then(|cwd| RelPath::new(cwd, PathStyle::local()).ok())
-            .and_then(|cwd_stripped| {
-                (cwd_stripped.as_ref() != RelPath::empty()).then(|| {
-                    is_cwd_in_worktree = true;
-                    cwd_stripped
-                })
-            });
-
-        for path_with_position in &potential_paths {
-            let path_to_check = if worktree_root.ends_with(&path_with_position.path) {
-                let root_path_with_position = PathWithPosition {
-                    path: worktree_root.to_path_buf(),
-                    row: path_with_position.row,
-                    column: path_with_position.column,
-                };
-                match worktree.read(cx).root_entry() {
-                    Some(root_entry) => {
-                        open_target = Some(OpenTarget::Worktree(
-                            root_path_with_position,
-                            root_entry.clone(),
-                            #[cfg(test)]
-                            OpenTargetFoundBy::WorktreeExact,
-                        ));
-                        break 'worktree_loop;
-                    }
-                    None => root_path_with_position,
-                }
-            } else {
-                PathWithPosition {
-                    path: path_with_position
-                        .path
-                        .strip_prefix(&worktree_root)
-                        .unwrap_or(&path_with_position.path)
-                        .to_owned(),
-                    row: path_with_position.row,
-                    column: path_with_position.column,
-                }
-            };
-
-            // Normalize the path by joining with cwd if available (handles `.` and `..` segments)
-            let normalized_path = if path_to_check.path.is_relative() {
-                relative_cwd.as_ref().and_then(|relative_cwd| {
-                    let joined = relative_cwd
-                        .as_ref()
-                        .as_std_path()
-                        .join(&path_to_check.path);
-                    normalize_lexically(&joined).ok().and_then(|p| {
-                        RelPath::new(&p, PathStyle::local())
-                            .ok()
-                            .map(std::borrow::Cow::into_owned)
-                    })
-                })
-            } else {
-                None
-            };
-            let original_path = RelPath::new(&path_to_check.path, PathStyle::local()).ok();
-
-            if !worktree.read(cx).is_single_file()
-                && let Some(entry) = normalized_path
-                    .as_ref()
-                    .and_then(|p| worktree.read(cx).entry_for_path(p))
-                    .or_else(|| {
-                        original_path
-                            .as_ref()
-                            .and_then(|p| worktree.read(cx).entry_for_path(p.as_ref()))
-                    })
-            {
-                open_target = Some(OpenTarget::Worktree(
-                    PathWithPosition {
-                        path: worktree.read(cx).absolutize(&entry.path),
-                        row: path_to_check.row,
-                        column: path_to_check.column,
-                    },
-                    entry.clone(),
-                    #[cfg(test)]
-                    OpenTargetFoundBy::WorktreeExact,
-                ));
-                break 'worktree_loop;
-            }
-
-            paths_to_check.push(path_to_check);
-        }
-
-        if !paths_to_check.is_empty() {
-            worktree_paths_to_check.push((worktree.clone(), paths_to_check));
-        }
-    }
-
-    #[cfg(not(test))]
-    let enable_background_fs_checks = workspace.read(cx).project().read(cx).is_local();
-    #[cfg(test)]
-    let enable_background_fs_checks = background_fs_checks == BackgroundFsChecks::Enabled;
-
-    if open_target.is_some() {
-        // We we want to prefer open targets found via background fs checks over worktree matches,
-        // however we can return early if either:
-        //   - This is a remote project, or
-        //   - If the terminal working directory is inside of at least one worktree
-        if !enable_background_fs_checks || is_cwd_in_worktree {
-            return Task::ready(open_target);
-        }
-    }
-
-    // Before entire worktree traversal(s), make an attempt to do FS checks if available.
-    let fs_paths_to_check =
-        if enable_background_fs_checks {
-            let fs_cwd_paths_to_check = cwd
-                .iter()
-                .flat_map(|cwd| {
-                    let mut paths_to_check = Vec::new();
-                    for path_to_check in &potential_paths {
-                        let maybe_path = &path_to_check.path;
-                        if path_to_check.path.is_relative() {
-                            paths_to_check.push(PathWithPosition {
-                                path: cwd.join(&maybe_path),
-                                row: path_to_check.row,
-                                column: path_to_check.column,
-                            });
-                        }
-                    }
-                    paths_to_check
-                })
-                .collect::<Vec<_>>();
-            fs_cwd_paths_to_check
-                .into_iter()
-                .chain(
-                    potential_paths
-                        .into_iter()
-                        .flat_map(|path_to_check| {
-                            let mut paths_to_check = Vec::new();
-                            let maybe_path = &path_to_check.path;
-                            if maybe_path.starts_with("~") {
-                                if let Some(home_path) = maybe_path.strip_prefix("~").ok().and_then(
-                                    |stripped_maybe_path| {
-                                        Some(dirs::home_dir()?.join(stripped_maybe_path))
-                                    },
-                                ) {
-                                    paths_to_check.push(PathWithPosition {
-                                        path: home_path,
-                                        row: path_to_check.row,
-                                        column: path_to_check.column,
-                                    });
-                                }
-                            } else {
-                                paths_to_check.push(PathWithPosition {
-                                    path: maybe_path.clone(),
-                                    row: path_to_check.row,
-                                    column: path_to_check.column,
-                                });
-                                if maybe_path.is_relative() {
-                                    for worktree in &worktree_candidates {
-                                        if !worktree.read(cx).is_single_file() {
-                                            paths_to_check.push(PathWithPosition {
-                                                path: worktree.read(cx).abs_path().join(maybe_path),
-                                                row: path_to_check.row,
-                                                column: path_to_check.column,
-                                            });
-                                        }
-                                    }
-                                }
-                            }
-                            paths_to_check
-                        })
-                        .collect::<Vec<_>>(),
-                )
-                .collect()
-        } else {
-            Vec::new()
-        };
-
-    let fs = workspace.read(cx).project().read(cx).fs().clone();
-    let background_fs_checks_task = cx.background_spawn(async move {
-        for mut path_to_check in fs_paths_to_check {
-            if let Some(fs_path_to_check) = fs.canonicalize(&path_to_check.path).await.ok()
-                && let Some(metadata) = fs.metadata(&fs_path_to_check).await.ok().flatten()
-            {
-                if open_target
-                    .as_ref()
-                    .map(|open_target| open_target.path().path != fs_path_to_check)
-                    .unwrap_or(true)
-                {
-                    path_to_check.path = fs_path_to_check;
-                    return Some(OpenTarget::File(path_to_check, metadata));
-                }
-
-                break;
-            }
-        }
-
-        open_target
-    });
-
-    cx.spawn(async move |cx| {
-        background_fs_checks_task.await.or_else(|| {
-            for (worktree, worktree_paths_to_check) in worktree_paths_to_check {
-                if let Some(found_entry) =
-                    worktree.update(cx, |worktree, _| -> Option<OpenTarget> {
-                        let traversal =
-                            worktree.traverse_from_path(true, true, false, RelPath::empty());
-                        for entry in traversal {
-                            if let Some(path_in_worktree) =
-                                worktree_paths_to_check.iter().find(|path_to_check| {
-                                    RelPath::new(&path_to_check.path, PathStyle::local())
-                                        .is_ok_and(|path| entry.path.ends_with(&path))
-                                })
-                            {
-                                return Some(OpenTarget::Worktree(
-                                    PathWithPosition {
-                                        path: worktree.absolutize(&entry.path),
-                                        row: path_in_worktree.row,
-                                        column: path_in_worktree.column,
-                                    },
-                                    entry.clone(),
-                                    #[cfg(test)]
-                                    OpenTargetFoundBy::WorktreeScan,
-                                ));
-                            }
-                        }
-                        None
-                    })
-                {
-                    return Some(found_entry);
-                }
-            }
-            None
-        })
-    })
-}
-
 pub(super) fn open_path_like_target(
     workspace: &WeakEntity<Workspace>,
     terminal_view: &mut TerminalView,
@@ -455,13 +118,25 @@ fn possibly_open_target(
     cx.spawn_in(window, async move |terminal_view, cx| {
         let Some(open_target) = terminal_view
             .update(cx, |_, cx| {
-                possible_open_target(
-                    &workspace,
-                    &path_like_target,
-                    cx,
-                    #[cfg(test)]
-                    background_fs_checks,
-                )
+                #[cfg(not(test))]
+                {
+                    possible_open_target(
+                        &workspace,
+                        &path_like_target.maybe_path,
+                        path_like_target.terminal_dir.as_deref(),
+                        cx,
+                    )
+                }
+                #[cfg(test)]
+                {
+                    possible_open_target_with_fs_checks(
+                        &workspace,
+                        &path_like_target.maybe_path,
+                        path_like_target.terminal_dir.as_deref(),
+                        cx,
+                        background_fs_checks,
+                    )
+                }
             })?
             .await
         else {
@@ -530,7 +205,7 @@ fn possibly_open_target(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use gpui::TestAppContext;
+    use gpui::{AppContext as _, TestAppContext};
     use project::Project;
     use serde_json::json;
     use std::path::{Path, PathBuf};
@@ -540,6 +215,7 @@ mod tests {
         terminal_settings::{AlternateScroll, CursorShape},
     };
     use util::path;
+    use util::paths::PathStyle;
     use workspace::{AppState, MultiWorkspace};
 
     async fn init_test(
diff --git a/crates/workspace/Cargo.toml b/crates/workspace/Cargo.toml
index 0200f1b7d57..4bee4ba8c08 100644
--- a/crates/workspace/Cargo.toml
+++ b/crates/workspace/Cargo.toml
@@ -36,6 +36,7 @@ clock.workspace = true
 collections.workspace = true
 component.workspace = true
 db.workspace = true
+dirs.workspace = true
 futures-lite.workspace = true
 fs.workspace = true
 futures.workspace = true
diff --git a/crates/workspace/src/path_link.rs b/crates/workspace/src/path_link.rs
new file mode 100644
index 00000000000..e707a7de603
--- /dev/null
+++ b/crates/workspace/src/path_link.rs
@@ -0,0 +1,422 @@
+use crate::Workspace;
+use gpui::{App, AppContext, Task, WeakEntity};
+use itertools::Itertools;
+use project::{Entry, Metadata};
+use std::path::{Path, PathBuf};
+use util::{
+    paths::{PathStyle, PathWithPosition, normalize_lexically},
+    rel_path::RelPath,
+};
+
+#[cfg(any(test, feature = "test-support"))]
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum OpenTargetFoundBy {
+    WorktreeExact,
+    WorktreeScan,
+    FileSystemBackground,
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum BackgroundFsChecks {
+    Enabled,
+    Disabled,
+}
+
+#[derive(Debug, Clone)]
+pub enum OpenTarget {
+    Worktree(
+        PathWithPosition,
+        Entry,
+        #[cfg(any(test, feature = "test-support"))] OpenTargetFoundBy,
+    ),
+    File(PathWithPosition, Metadata),
+}
+
+impl OpenTarget {
+    pub fn is_file(&self) -> bool {
+        match self {
+            OpenTarget::Worktree(_, entry, ..) => entry.is_file(),
+            OpenTarget::File(_, metadata) => !metadata.is_dir,
+        }
+    }
+
+    pub fn is_dir(&self) -> bool {
+        match self {
+            OpenTarget::Worktree(_, entry, ..) => entry.is_dir(),
+            OpenTarget::File(_, metadata) => metadata.is_dir,
+        }
+    }
+
+    pub fn path(&self) -> &PathWithPosition {
+        match self {
+            OpenTarget::Worktree(path, ..) => path,
+            OpenTarget::File(path, _) => path,
+        }
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub fn found_by(&self) -> OpenTargetFoundBy {
+        match self {
+            OpenTarget::Worktree(.., found_by) => *found_by,
+            OpenTarget::File(..) => OpenTargetFoundBy::FileSystemBackground,
+        }
+    }
+}
+
+pub fn sanitize_path_text(text: &str) -> &str {
+    let start = first_unbalanced_open_paren(text).unwrap_or(0);
+    let mut sanitized = &text[start..];
+    let (open_parens, mut close_parens) =
+        sanitized
+            .chars()
+            .fold((0, 0), |(opens, closes), character| match character {
+                '(' => (opens + 1, closes),
+                ')' => (opens, closes + 1),
+                _ => (opens, closes),
+            });
+
+    while let Some(last_char) = sanitized.chars().last() {
+        let should_remove = match last_char {
+            '.' | ',' | ':' | ';' => true,
+            '(' => true,
+            ')' if close_parens > open_parens => {
+                close_parens -= 1;
+                true
+            }
+            _ => false,
+        };
+
+        if should_remove {
+            sanitized = &sanitized[..sanitized.len() - last_char.len_utf8()];
+        } else {
+            break;
+        }
+    }
+
+    sanitized
+}
+
+/// Returns the byte offset just past the first unbalanced `(` in `text`, or
+/// `None` if all parentheses are balanced.
+pub fn first_unbalanced_open_paren(text: &str) -> Option<usize> {
+    let mut balance: i32 = 0;
+    let mut first_unmatched = None;
+    for (index, character) in text.char_indices() {
+        match character {
+            '(' => {
+                if balance == 0 {
+                    first_unmatched = Some(index + character.len_utf8());
+                }
+                balance += 1;
+            }
+            ')' => {
+                balance -= 1;
+                if balance <= 0 {
+                    balance = 0;
+                    first_unmatched = None;
+                }
+            }
+            _ => {}
+        }
+    }
+    first_unmatched.filter(|_| balance > 0)
+}
+
+pub fn possible_open_target(
+    workspace: &WeakEntity<Workspace>,
+    maybe_path: &str,
+    cwd: Option<&Path>,
+    cx: &App,
+) -> Task<Option<OpenTarget>> {
+    possible_open_target_internal(workspace, maybe_path, cwd, cx, None)
+}
+
+#[cfg(any(test, feature = "test-support"))]
+pub fn possible_open_target_with_fs_checks(
+    workspace: &WeakEntity<Workspace>,
+    maybe_path: &str,
+    cwd: Option<&Path>,
+    cx: &App,
+    background_fs_checks: BackgroundFsChecks,
+) -> Task<Option<OpenTarget>> {
+    possible_open_target_internal(workspace, maybe_path, cwd, cx, Some(background_fs_checks))
+}
+
+fn possible_open_target_internal(
+    workspace: &WeakEntity<Workspace>,
+    maybe_path: &str,
+    cwd: Option<&Path>,
+    cx: &App,
+    background_fs_checks: Option<BackgroundFsChecks>,
+) -> Task<Option<OpenTarget>> {
+    let Some(workspace) = workspace.upgrade() else {
+        return Task::ready(None);
+    };
+
+    let mut potential_paths = Vec::new();
+    let original_path = PathWithPosition::from_path(PathBuf::from(maybe_path));
+    let path_with_position = PathWithPosition::parse_str(maybe_path);
+    let worktree_candidates = workspace
+        .read(cx)
+        .worktrees(cx)
+        .sorted_by_key(|worktree| {
+            let worktree_root = worktree.read(cx).abs_path();
+            match cwd.and_then(|cwd| worktree_root.strip_prefix(cwd).ok()) {
+                Some(cwd_child) => cwd_child.components().count(),
+                None => usize::MAX,
+            }
+        })
+        .collect::<Vec<_>>();
+
+    const GIT_DIFF_PATH_PREFIXES: &[&str] = &["a", "b"];
+    for prefix_str in GIT_DIFF_PATH_PREFIXES.iter().chain(std::iter::once(&".")) {
+        if let Some(stripped) = original_path.path.strip_prefix(prefix_str).ok() {
+            potential_paths.push(PathWithPosition {
+                path: stripped.to_owned(),
+                row: original_path.row,
+                column: original_path.column,
+            });
+        }
+        if let Some(stripped) = path_with_position.path.strip_prefix(prefix_str).ok() {
+            potential_paths.push(PathWithPosition {
+                path: stripped.to_owned(),
+                row: path_with_position.row,
+                column: path_with_position.column,
+            });
+        }
+    }
+
+    let insert_both_paths = original_path != path_with_position;
+    potential_paths.insert(0, original_path);
+    if insert_both_paths {
+        potential_paths.insert(1, path_with_position);
+    }
+
+    let mut worktree_paths_to_check = Vec::new();
+    let mut is_cwd_in_worktree = false;
+    let mut open_target = None;
+    'worktree_loop: for worktree in &worktree_candidates {
+        let worktree_root = worktree.read(cx).abs_path();
+        let mut paths_to_check = Vec::with_capacity(potential_paths.len());
+        let relative_cwd = cwd
+            .and_then(|cwd| cwd.strip_prefix(&worktree_root).ok())
+            .and_then(|cwd| RelPath::new(cwd, PathStyle::local()).ok())
+            .and_then(|cwd_stripped| {
+                (cwd_stripped.as_ref() != RelPath::empty()).then(|| {
+                    is_cwd_in_worktree = true;
+                    cwd_stripped
+                })
+            });
+
+        for path_with_position in &potential_paths {
+            let path_to_check = if worktree_root.ends_with(&path_with_position.path) {
+                let root_path_with_position = PathWithPosition {
+                    path: worktree_root.to_path_buf(),
+                    row: path_with_position.row,
+                    column: path_with_position.column,
+                };
+                match worktree.read(cx).root_entry() {
+                    Some(root_entry) => {
+                        open_target = Some(OpenTarget::Worktree(
+                            root_path_with_position,
+                            root_entry.clone(),
+                            #[cfg(any(test, feature = "test-support"))]
+                            OpenTargetFoundBy::WorktreeExact,
+                        ));
+                        break 'worktree_loop;
+                    }
+                    None => root_path_with_position,
+                }
+            } else {
+                PathWithPosition {
+                    path: path_with_position
+                        .path
+                        .strip_prefix(&worktree_root)
+                        .unwrap_or(&path_with_position.path)
+                        .to_owned(),
+                    row: path_with_position.row,
+                    column: path_with_position.column,
+                }
+            };
+
+            let normalized_path = if path_to_check.path.is_relative() {
+                relative_cwd.as_ref().and_then(|relative_cwd| {
+                    let joined = relative_cwd
+                        .as_ref()
+                        .as_std_path()
+                        .join(&path_to_check.path);
+                    normalize_lexically(&joined).ok().and_then(|path| {
+                        RelPath::new(&path, PathStyle::local())
+                            .ok()
+                            .map(std::borrow::Cow::into_owned)
+                    })
+                })
+            } else {
+                None
+            };
+            let original_path = RelPath::new(&path_to_check.path, PathStyle::local()).ok();
+
+            if !worktree.read(cx).is_single_file()
+                && let Some(entry) = normalized_path
+                    .as_ref()
+                    .and_then(|path| worktree.read(cx).entry_for_path(path))
+                    .or_else(|| {
+                        original_path
+                            .as_ref()
+                            .and_then(|path| worktree.read(cx).entry_for_path(path.as_ref()))
+                    })
+            {
+                open_target = Some(OpenTarget::Worktree(
+                    PathWithPosition {
+                        path: worktree.read(cx).absolutize(&entry.path),
+                        row: path_to_check.row,
+                        column: path_to_check.column,
+                    },
+                    entry.clone(),
+                    #[cfg(any(test, feature = "test-support"))]
+                    OpenTargetFoundBy::WorktreeExact,
+                ));
+                break 'worktree_loop;
+            }
+
+            paths_to_check.push(path_to_check);
+        }
+
+        if !paths_to_check.is_empty() {
+            worktree_paths_to_check.push((worktree.clone(), paths_to_check));
+        }
+    }
+
+    let enable_background_fs_checks = background_fs_checks
+        .map(|background_fs_checks| background_fs_checks == BackgroundFsChecks::Enabled)
+        .unwrap_or_else(|| workspace.read(cx).project().read(cx).is_local());
+
+    if open_target.is_some() {
+        if !enable_background_fs_checks || is_cwd_in_worktree {
+            return Task::ready(open_target);
+        }
+    }
+
+    let fs_paths_to_check = if enable_background_fs_checks {
+        let fs_cwd_paths_to_check = cwd
+            .iter()
+            .flat_map(|cwd| {
+                let mut paths_to_check = Vec::new();
+                for path_to_check in &potential_paths {
+                    let maybe_path = &path_to_check.path;
+                    if path_to_check.path.is_relative() {
+                        paths_to_check.push(PathWithPosition {
+                            path: cwd.join(maybe_path),
+                            row: path_to_check.row,
+                            column: path_to_check.column,
+                        });
+                    }
+                }
+                paths_to_check
+            })
+            .collect::<Vec<_>>();
+        fs_cwd_paths_to_check
+            .into_iter()
+            .chain(
+                potential_paths
+                    .into_iter()
+                    .flat_map(|path_to_check| {
+                        let mut paths_to_check = Vec::new();
+                        let maybe_path = &path_to_check.path;
+                        if maybe_path.starts_with("~") {
+                            if let Some(home_path) = maybe_path
+                                .strip_prefix("~")
+                                .ok()
+                                .and_then(|stripped| Some(dirs::home_dir()?.join(stripped)))
+                            {
+                                paths_to_check.push(PathWithPosition {
+                                    path: home_path,
+                                    row: path_to_check.row,
+                                    column: path_to_check.column,
+                                });
+                            }
+                        } else {
+                            paths_to_check.push(PathWithPosition {
+                                path: maybe_path.clone(),
+                                row: path_to_check.row,
+                                column: path_to_check.column,
+                            });
+                            if maybe_path.is_relative() {
+                                for worktree in &worktree_candidates {
+                                    if !worktree.read(cx).is_single_file() {
+                                        paths_to_check.push(PathWithPosition {
+                                            path: worktree.read(cx).abs_path().join(maybe_path),
+                                            row: path_to_check.row,
+                                            column: path_to_check.column,
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                        paths_to_check
+                    })
+                    .collect::<Vec<_>>(),
+            )
+            .collect()
+    } else {
+        Vec::new()
+    };
+
+    let fs = workspace.read(cx).project().read(cx).fs().clone();
+    let background_fs_checks_task = cx.background_spawn(async move {
+        for mut path_to_check in fs_paths_to_check {
+            if let Some(fs_path_to_check) = fs.canonicalize(&path_to_check.path).await.ok()
+                && let Some(metadata) = fs.metadata(&fs_path_to_check).await.ok().flatten()
+            {
+                if open_target
+                    .as_ref()
+                    .map(|open_target| open_target.path().path != fs_path_to_check)
+                    .unwrap_or(true)
+                {
+                    path_to_check.path = fs_path_to_check;
+                    return Some(OpenTarget::File(path_to_check, metadata));
+                }
+
+                break;
+            }
+        }
+
+        open_target
+    });
+
+    cx.spawn(async move |cx| {
+        background_fs_checks_task.await.or_else(|| {
+            for (worktree, worktree_paths_to_check) in worktree_paths_to_check {
+                if let Some(found_entry) =
+                    worktree.update(cx, |worktree, _| -> Option<OpenTarget> {
+                        let traversal =
+                            worktree.traverse_from_path(true, true, false, RelPath::empty());
+                        for entry in traversal {
+                            if let Some(path_in_worktree) =
+                                worktree_paths_to_check.iter().find(|path_to_check| {
+                                    RelPath::new(&path_to_check.path, PathStyle::local())
+                                        .is_ok_and(|path| entry.path.ends_with(&path))
+                                })
+                            {
+                                return Some(OpenTarget::Worktree(
+                                    PathWithPosition {
+                                        path: worktree.absolutize(&entry.path),
+                                        row: path_in_worktree.row,
+                                        column: path_in_worktree.column,
+                                    },
+                                    entry.clone(),
+                                    #[cfg(any(test, feature = "test-support"))]
+                                    OpenTargetFoundBy::WorktreeScan,
+                                ));
+                            }
+                        }
+                        None
+                    })
+                {
+                    return Some(found_entry);
+                }
+            }
+            None
+        })
+    })
+}
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index b3bafd0bb6b..dbe132add88 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -13,6 +13,7 @@ pub mod pane_group;
 pub mod path_list {
     pub use util::path_list::{PathList, SerializedPathList};
 }
+pub mod path_link;
 mod persistence;
 pub mod searchable;
 pub mod security_modal;

From da66f9523743e97eed4e8d10bca12d678640e7d1 Mon Sep 17 00:00:00 2001
From: Cole Miller <cole@zed.dev>
Date: Thu, 21 May 2026 18:16:01 -0400
Subject: [PATCH 098/105] Make the commit editor's font size independently
 configurable (#56077)

- Add a separate `git_commit_buffer_font_size` setting, defaulting to
`12px` (the previous default before it was changed to use the buffer
font size)
- Add in-memory buffer font size overrides for zooming the commit modal
and in-panel editor

Self-Review Checklist:

- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [ ] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable

Release Notes:

- Added a `git_commit_buffer_font_size` setting and made the in-panel
and modal commit message editors zoomable.
---
 assets/settings/default.json                |   2 +
 crates/git_ui/src/commit_modal.rs           |  44 +++++++-
 crates/git_ui/src/git_panel.rs              | 115 +++++++++++---------
 crates/settings/src/vscode_import.rs        |   1 +
 crates/settings_content/src/theme.rs        |   1 +
 crates/theme_settings/src/settings.rs       |  35 ++++++
 crates/theme_settings/src/theme_settings.rs |  22 +++-
 7 files changed, 159 insertions(+), 61 deletions(-)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index ca782b5c8e8..17f35962a8f 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -71,6 +71,8 @@
   "agent_ui_font_size": null,
   // The default font size for user messages in the agent panel.
   "agent_buffer_font_size": 12,
+  // The default font size for the commit editor in the git panel and commit modal.
+  "git_commit_buffer_font_size": 12,
   // How much to fade out unused code.
   "unnecessary_code_fade": 0.3,
   // Active pane styling settings.
diff --git a/crates/git_ui/src/commit_modal.rs b/crates/git_ui/src/commit_modal.rs
index 5da2f670f31..4631d781bf0 100644
--- a/crates/git_ui/src/commit_modal.rs
+++ b/crates/git_ui/src/commit_modal.rs
@@ -1,6 +1,6 @@
 use crate::branch_picker::{self, BranchList};
 use crate::git_panel::{
-    GitPanel, commit_message_editor, commit_title_exceeds_limit, panel_editor_style,
+    GitPanel, commit_message_editor, commit_title_exceeds_limit, git_commit_editor_style,
 };
 use crate::git_panel_settings::GitPanelSettings;
 use git::repository::CommitOptions;
@@ -10,6 +10,7 @@ use settings::Settings;
 use ui::{
     ContextMenu, KeybindingHint, PopoverMenu, PopoverMenuHandle, SplitButton, Tooltip, prelude::*,
 };
+use zed_actions::{DecreaseBufferFontSize, IncreaseBufferFontSize, ResetBufferFontSize};
 
 use editor::{Editor, EditorElement};
 use gpui::*;
@@ -228,8 +229,9 @@ impl CommitModal {
         }
     }
 
-    fn commit_editor_element(&self, window: &mut Window, cx: &mut Context<Self>) -> EditorElement {
-        let editor_style = panel_editor_style(true, window, cx);
+    fn commit_editor_element(&self, _window: &mut Window, cx: &mut Context<Self>) -> EditorElement {
+        let settings = theme_settings::ThemeSettings::get_global(cx);
+        let editor_style = git_commit_editor_style(settings.git_commit_buffer_font_size(cx), cx);
         EditorElement::new(&self.commit_editor, editor_style)
     }
 
@@ -533,6 +535,39 @@ impl CommitModal {
             self.branch_list_handle.toggle(window, cx);
         }
     }
+
+    fn increase_font_size(
+        &mut self,
+        action: &IncreaseBufferFontSize,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.git_panel.update(cx, |git_panel, cx| {
+            git_panel.increase_font_size(action, window, cx);
+        });
+    }
+
+    fn decrease_font_size(
+        &mut self,
+        action: &DecreaseBufferFontSize,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.git_panel.update(cx, |git_panel, cx| {
+            git_panel.decrease_font_size(action, window, cx);
+        });
+    }
+
+    fn reset_font_size(
+        &mut self,
+        action: &ResetBufferFontSize,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.git_panel.update(cx, |git_panel, cx| {
+            git_panel.reset_font_size(action, window, cx);
+        });
+    }
 }
 
 impl Render for CommitModal {
@@ -561,6 +596,9 @@ impl Render for CommitModal {
             .on_action(cx.listener(Self::dismiss))
             .on_action(cx.listener(Self::on_commit))
             .on_action(cx.listener(Self::on_amend))
+            .on_action(cx.listener(Self::increase_font_size))
+            .on_action(cx.listener(Self::decrease_font_size))
+            .on_action(cx.listener(Self::reset_font_size))
             .when(!DisableAiSettings::get_global(cx).disable_ai, |this| {
                 this.on_action(cx.listener(|this, _: &GenerateCommitMessage, _, cx| {
                     this.git_panel.update(cx, |panel, cx| {
diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs
index 1eee2d818b0..ef17b15cdea 100644
--- a/crates/git_ui/src/git_panel.rs
+++ b/crates/git_ui/src/git_panel.rs
@@ -65,7 +65,7 @@ use project::{
 use prompt_store::{BuiltInPrompt, PromptId, PromptStore, RULES_FILE_NAMES};
 use proto::RpcError;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsStore, StatusStyle};
+use settings::{Settings, SettingsStore, StatusStyle, update_settings_file};
 use smallvec::SmallVec;
 use std::future::Future;
 use std::ops::Range;
@@ -87,6 +87,7 @@ use workspace::{
     dock::{DockPosition, Panel, PanelEvent},
     notifications::{DetachAndPromptErr, ErrorMessagePrompt, NotificationId, NotifyResultExt},
 };
+use zed_actions::{DecreaseBufferFontSize, IncreaseBufferFontSize, ResetBufferFontSize};
 
 actions!(
     git_panel,
@@ -3456,6 +3457,54 @@ impl GitPanel {
         }
     }
 
+    pub(crate) fn increase_font_size(
+        &mut self,
+        action: &IncreaseBufferFontSize,
+        _: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.handle_font_size_action(action.persist, px(1.0), cx);
+    }
+
+    pub(crate) fn decrease_font_size(
+        &mut self,
+        action: &DecreaseBufferFontSize,
+        _: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.handle_font_size_action(action.persist, px(-1.0), cx);
+    }
+
+    fn handle_font_size_action(&mut self, persist: bool, delta: Pixels, cx: &mut Context<Self>) {
+        if persist {
+            update_settings_file(self.fs.clone(), cx, move |settings, cx| {
+                let git_commit_buffer_font_size =
+                    ThemeSettings::get_global(cx).git_commit_buffer_font_size(cx) + delta;
+
+                let _ = settings.theme.git_commit_buffer_font_size.insert(
+                    f32::from(theme_settings::clamp_font_size(git_commit_buffer_font_size)).into(),
+                );
+            });
+        } else {
+            theme_settings::adjust_git_commit_buffer_font_size(cx, |size| size + delta);
+        }
+    }
+
+    pub(crate) fn reset_font_size(
+        &mut self,
+        action: &ResetBufferFontSize,
+        _: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if action.persist {
+            update_settings_file(self.fs.clone(), cx, move |settings, _| {
+                settings.theme.git_commit_buffer_font_size = None;
+            });
+        } else {
+            theme_settings::reset_git_commit_buffer_font_size(cx);
+        }
+    }
+
     fn toggle_directory(&mut self, key: &TreeKey, window: &mut Window, cx: &mut Context<Self>) {
         if let Some(state) = self.view_mode.tree_state_mut() {
             let expanded = state.expanded_dirs.entry(key.clone()).or_insert(true);
@@ -4555,7 +4604,9 @@ impl GitPanel {
         cx: &mut Context<Self>,
     ) -> Option<impl IntoElement> {
         let active_repository = self.active_repository.clone()?;
-        let panel_editor_style = panel_editor_style(true, window, cx);
+        let settings = ThemeSettings::get_global(cx);
+        let panel_editor_style =
+            git_commit_editor_style(settings.git_commit_buffer_font_size(cx), cx);
         let enable_coauthors = self.render_co_authors(cx);
         let editor_focus_handle = self.commit_editor.focus_handle(cx);
         let branch = active_repository.read(cx).branch.clone();
@@ -6626,6 +6677,9 @@ impl Render for GitPanel {
             })
             .on_action(cx.listener(Self::toggle_sort_by_path))
             .on_action(cx.listener(Self::toggle_tree_view))
+            .on_action(cx.listener(Self::increase_font_size))
+            .on_action(cx.listener(Self::decrease_font_size))
+            .on_action(cx.listener(Self::reset_font_size))
             .on_action(cx.listener(Self::activate_changes_tab))
             .on_action(cx.listener(Self::activate_history_tab))
             .size_full()
@@ -6790,42 +6844,20 @@ pub fn panel_editor_container(_window: &mut Window, cx: &mut App) -> Div {
         .bg(cx.theme().colors().editor_background)
 }
 
-pub(crate) fn panel_editor_style(monospace: bool, window: &Window, cx: &App) -> EditorStyle {
+pub(crate) fn git_commit_editor_style(font_size: gpui::Pixels, cx: &App) -> EditorStyle {
     let settings = ThemeSettings::get_global(cx);
 
-    let (font_family, font_fallbacks, font_features, font_size, font_weight, line_height) =
-        if monospace {
-            let font_size = settings.buffer_font_size(cx);
-            (
-                settings.buffer_font.family.clone(),
-                settings.buffer_font.fallbacks.clone(),
-                settings.buffer_font.features.clone(),
-                AbsoluteLength::from(font_size),
-                settings.buffer_font.weight,
-                font_size * settings.buffer_line_height.value(),
-            )
-        } else {
-            (
-                settings.ui_font.family.clone(),
-                settings.ui_font.fallbacks.clone(),
-                settings.ui_font.features.clone(),
-                AbsoluteLength::from(TextSize::Small.rems(cx)),
-                settings.ui_font.weight,
-                window.line_height(),
-            )
-        };
-
     EditorStyle {
         background: cx.theme().colors().editor_background,
         local_player: cx.theme().players().local(),
         text: TextStyle {
             color: cx.theme().colors().text,
-            font_family,
-            font_fallbacks,
-            font_features,
-            font_size,
-            font_weight,
-            line_height: line_height.into(),
+            font_family: settings.buffer_font.family.clone(),
+            font_fallbacks: settings.buffer_font.fallbacks.clone(),
+            font_features: settings.buffer_font.features.clone(),
+            font_size: AbsoluteLength::from(font_size),
+            font_weight: settings.buffer_font.weight,
+            line_height: (font_size * settings.buffer_line_height.value()).into(),
             ..Default::default()
         },
         syntax: cx.theme().syntax().clone(),
@@ -9150,25 +9182,4 @@ mod tests {
             ));
         });
     }
-
-    #[gpui::test]
-    async fn test_panel_editor_style_uses_buffer_font_size(cx: &mut TestAppContext) {
-        init_test(cx);
-
-        cx.update(|cx| {
-            SettingsStore::update_global(cx, |store, cx| {
-                store.update_user_settings(cx, |settings| {
-                    settings.theme.buffer_font_size = Some(20.0.into());
-                });
-            });
-        });
-
-        cx.add_window(|window, cx| {
-            let style = panel_editor_style(true, window, cx);
-
-            assert_eq!(style.text.font_size.to_pixels(window.rem_size()), px(20.0));
-
-            Editor::single_line(window, cx)
-        });
-    }
 }
diff --git a/crates/settings/src/vscode_import.rs b/crates/settings/src/vscode_import.rs
index 236f0da3403..43808c7b153 100644
--- a/crates/settings/src/vscode_import.rs
+++ b/crates/settings/src/vscode_import.rs
@@ -977,6 +977,7 @@ impl VsCodeSettings {
             buffer_font_features: None,
             agent_ui_font_size: None,
             agent_buffer_font_size: None,
+            git_commit_buffer_font_size: None,
             markdown_preview_font_family: None,
             markdown_preview_code_font_family: None,
             markdown_preview_theme: None,
diff --git a/crates/settings_content/src/theme.rs b/crates/settings_content/src/theme.rs
index 4d33d0d9b9d..305e1d40530 100644
--- a/crates/settings_content/src/theme.rs
+++ b/crates/settings_content/src/theme.rs
@@ -149,6 +149,7 @@ pub struct ThemeSettingsContent {
     pub agent_ui_font_size: Option<FontSize>,
     /// The font size for user messages in the agent panel.
     pub agent_buffer_font_size: Option<FontSize>,
+    pub git_commit_buffer_font_size: Option<FontSize>,
     /// The name of a font to use for rendering in the markdown preview.
     /// Falls back to the UI font if unset.
     pub markdown_preview_font_family: Option<FontFamilyName>,
diff --git a/crates/theme_settings/src/settings.rs b/crates/theme_settings/src/settings.rs
index c9f220a923c..3d36f08aa58 100644
--- a/crates/theme_settings/src/settings.rs
+++ b/crates/theme_settings/src/settings.rs
@@ -56,6 +56,7 @@ pub struct ThemeSettings {
     agent_ui_font_size: Option<Pixels>,
     /// The agent buffer font size. Determines the size of user messages in the agent panel.
     agent_buffer_font_size: Option<Pixels>,
+    git_commit_buffer_font_size: Option<Pixels>,
     /// The font family to use for rendering in the markdown preview.
     /// Falls back to the UI font family if unset.
     markdown_preview_font_family: Option<SharedString>,
@@ -118,6 +119,11 @@ pub struct AgentBufferFontSize(Pixels);
 
 impl Global for AgentBufferFontSize {}
 
+#[derive(Default)]
+pub struct GitCommitBufferFontSize(Pixels);
+
+impl Global for GitCommitBufferFontSize {}
+
 /// Represents the selection of a theme, which can be either static or dynamic.
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
 #[serde(untagged)]
@@ -410,6 +416,14 @@ impl ThemeSettings {
             .unwrap_or_else(|| self.buffer_font_size(cx))
     }
 
+    pub fn git_commit_buffer_font_size(&self, cx: &App) -> Pixels {
+        cx.try_global::<GitCommitBufferFontSize>()
+            .map(|size| size.0)
+            .or(self.git_commit_buffer_font_size)
+            .map(clamp_font_size)
+            .unwrap_or_else(|| self.buffer_font_size(cx))
+    }
+
     /// Returns the font family to use in the markdown preview,
     /// falling back to the UI font family when unset.
     pub fn markdown_preview_font_family(&self) -> &SharedString {
@@ -458,6 +472,10 @@ impl ThemeSettings {
         self.agent_buffer_font_size
     }
 
+    pub fn git_commit_buffer_font_size_settings(&self) -> Option<Pixels> {
+        self.git_commit_buffer_font_size
+    }
+
     /// Returns the buffer's line height.
     pub fn line_height(&self) -> f32 {
         f32::max(self.buffer_line_height.value(), MIN_LINE_HEIGHT)
@@ -609,6 +627,22 @@ pub fn reset_agent_buffer_font_size(cx: &mut App) {
     }
 }
 
+pub fn adjust_git_commit_buffer_font_size(cx: &mut App, f: impl FnOnce(Pixels) -> Pixels) {
+    let git_commit_buffer_font_size = ThemeSettings::get_global(cx).git_commit_buffer_font_size(cx);
+    let adjusted_size = cx
+        .try_global::<GitCommitBufferFontSize>()
+        .map_or(git_commit_buffer_font_size, |adjusted_size| adjusted_size.0);
+    cx.set_global(GitCommitBufferFontSize(clamp_font_size(f(adjusted_size))));
+    cx.refresh_windows();
+}
+
+pub fn reset_git_commit_buffer_font_size(cx: &mut App) {
+    if cx.has_global::<GitCommitBufferFontSize>() {
+        cx.remove_global::<GitCommitBufferFontSize>();
+        cx.refresh_windows();
+    }
+}
+
 /// Ensures font size is within the valid range.
 pub fn clamp_font_size(size: Pixels) -> Pixels {
     size.clamp(MIN_FONT_SIZE, MAX_FONT_SIZE)
@@ -658,6 +692,7 @@ impl settings::Settings for ThemeSettings {
             buffer_line_height: content.buffer_line_height.unwrap().into(),
             agent_ui_font_size: content.agent_ui_font_size.map(|s| s.into_gpui()),
             agent_buffer_font_size: content.agent_buffer_font_size.map(|s| s.into_gpui()),
+            git_commit_buffer_font_size: content.git_commit_buffer_font_size.map(|s| s.into_gpui()),
             markdown_preview_font_family: content
                 .markdown_preview_font_family
                 .as_ref()
diff --git a/crates/theme_settings/src/theme_settings.rs b/crates/theme_settings/src/theme_settings.rs
index b5bf1a60283..192dfa54c47 100644
--- a/crates/theme_settings/src/theme_settings.rs
+++ b/crates/theme_settings/src/theme_settings.rs
@@ -28,12 +28,14 @@ pub use crate::schema::{
 };
 use crate::settings::adjust_buffer_font_size;
 pub use crate::settings::{
-    AgentBufferFontSize, AgentUiFontSize, BufferLineHeight, FontFamilyName, IconThemeName,
-    IconThemeSelection, ThemeAppearanceMode, ThemeName, ThemeSelection, ThemeSettings,
-    adjust_agent_buffer_font_size, adjust_agent_ui_font_size, adjust_ui_font_size,
-    adjusted_font_size, appearance_to_mode, clamp_font_size, default_theme,
-    observe_buffer_font_size_adjustment, reset_agent_buffer_font_size, reset_agent_ui_font_size,
-    reset_buffer_font_size, reset_ui_font_size, set_icon_theme, set_mode, set_theme, setup_ui_font,
+    AgentBufferFontSize, AgentUiFontSize, BufferLineHeight, FontFamilyName,
+    GitCommitBufferFontSize, IconThemeName, IconThemeSelection, ThemeAppearanceMode, ThemeName,
+    ThemeSelection, ThemeSettings, adjust_agent_buffer_font_size, adjust_agent_ui_font_size,
+    adjust_git_commit_buffer_font_size, adjust_ui_font_size, adjusted_font_size,
+    appearance_to_mode, clamp_font_size, default_theme, observe_buffer_font_size_adjustment,
+    reset_agent_buffer_font_size, reset_agent_ui_font_size, reset_buffer_font_size,
+    reset_git_commit_buffer_font_size, reset_ui_font_size, set_icon_theme, set_mode, set_theme,
+    setup_ui_font,
 };
 pub use theme::UiDensity;
 
@@ -87,6 +89,8 @@ pub fn init(themes_to_load: LoadThemes, cx: &mut App) {
     let mut prev_ui_font_size_settings = settings.ui_font_size_settings();
     let mut prev_agent_ui_font_size_settings = settings.agent_ui_font_size_settings();
     let mut prev_agent_buffer_font_size_settings = settings.agent_buffer_font_size_settings();
+    let mut prev_git_commit_buffer_font_size_settings =
+        settings.git_commit_buffer_font_size_settings();
     let mut prev_theme_name = settings.theme.name(SystemAppearance::global(cx).0);
     let mut prev_icon_theme_name = settings.icon_theme.name(SystemAppearance::global(cx).0);
     let mut prev_theme_overrides = (
@@ -101,6 +105,7 @@ pub fn init(themes_to_load: LoadThemes, cx: &mut App) {
         let ui_font_size_settings = settings.ui_font_size_settings();
         let agent_ui_font_size_settings = settings.agent_ui_font_size_settings();
         let agent_buffer_font_size_settings = settings.agent_buffer_font_size_settings();
+        let git_commit_buffer_font_size_settings = settings.git_commit_buffer_font_size_settings();
         let theme_name = settings.theme.name(SystemAppearance::global(cx).0);
         let icon_theme_name = settings.icon_theme.name(SystemAppearance::global(cx).0);
         let theme_overrides = (
@@ -128,6 +133,11 @@ pub fn init(themes_to_load: LoadThemes, cx: &mut App) {
             reset_agent_buffer_font_size(cx);
         }
 
+        if git_commit_buffer_font_size_settings != prev_git_commit_buffer_font_size_settings {
+            prev_git_commit_buffer_font_size_settings = git_commit_buffer_font_size_settings;
+            reset_git_commit_buffer_font_size(cx);
+        }
+
         if theme_name != prev_theme_name || theme_overrides != prev_theme_overrides {
             prev_theme_name = theme_name;
             prev_theme_overrides = theme_overrides;

From ba350974afa890c7dfce0abdf7a721773288de87 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Thu, 21 May 2026 16:40:35 -0600
Subject: [PATCH 099/105] Fix multiline text truncation (#57450)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Improves .text_truncate() in combination with .line_clamp()

<img width="384" height="124" alt="Screenshot 2026-05-21 at 4 28 59 PM"
src="https://github.com/user-attachments/assets/3decc78c-8d5d-4d34-84c5-4274a2d12bea"
/>
<img width="385" height="143" alt="Screenshot 2026-05-21 at 4 26 23 PM"
src="https://github.com/user-attachments/assets/f807b19a-6834-4504-9749-e16b8d68a7aa"
/>

This was previously broken because we assumed lines would break evenly.

Release Notes:

- Improved truncation of multi-line text in the UI
---
 crates/gpui/src/elements/text.rs            |  29 +-
 crates/gpui/src/text_system/line_wrapper.rs | 391 ++++++++++++++++++++
 2 files changed, 412 insertions(+), 8 deletions(-)

diff --git a/crates/gpui/src/elements/text.rs b/crates/gpui/src/elements/text.rs
index 2c900d2c25a..7c268c8b197 100644
--- a/crates/gpui/src/elements/text.rs
+++ b/crates/gpui/src/elements/text.rs
@@ -455,14 +455,27 @@ impl TextLayout {
                 }
 
                 let mut line_wrapper = cx.text_system().line_wrapper(text_style.font(), font_size);
-                let (text, runs) = if let Some(truncate_width) = truncate_width {
-                    line_wrapper.truncate_line(
-                        text.clone(),
-                        truncate_width,
-                        &truncation_affix,
-                        &runs,
-                        truncate_from,
-                    )
+                let (text, runs) = if truncate_width.is_some() {
+                    if let Some(max_lines) = text_style.line_clamp
+                        && let Some(wrap_width) = wrap_width
+                    {
+                        line_wrapper.truncate_wrapped_line(
+                            text.clone(),
+                            wrap_width,
+                            max_lines,
+                            &truncation_affix,
+                            &runs,
+                            truncate_from,
+                        )
+                    } else {
+                        line_wrapper.truncate_line(
+                            text.clone(),
+                            truncate_width.unwrap_or(Pixels::MAX),
+                            &truncation_affix,
+                            &runs,
+                            truncate_from,
+                        )
+                    }
                 } else {
                     (text.clone(), Cow::Borrowed(&*runs))
                 };
diff --git a/crates/gpui/src/text_system/line_wrapper.rs b/crates/gpui/src/text_system/line_wrapper.rs
index 0524bad84f0..3335e7b31d1 100644
--- a/crates/gpui/src/text_system/line_wrapper.rs
+++ b/crates/gpui/src/text_system/line_wrapper.rs
@@ -215,6 +215,150 @@ impl LineWrapper {
         }
     }
 
+    /// Truncate text to fit within a given number of wrapped lines.
+    ///
+    /// Unlike `truncate_line` which treats the text as a flat width budget
+    /// (`width * max_lines`), this method accounts for word-boundary wrapping:
+    /// it walks through characters once, tracking wrap boundaries and the
+    /// truncation point simultaneously. When text overflows on the last
+    /// allowed line, it truncates there and appends the affix.
+    ///
+    /// For `max_lines == 1`, this delegates to `truncate_line`.
+    pub fn truncate_wrapped_line<'a>(
+        &mut self,
+        text: SharedString,
+        wrap_width: Pixels,
+        max_lines: usize,
+        truncation_affix: &str,
+        runs: &'a [TextRun],
+        truncate_from: TruncateFrom,
+    ) -> (SharedString, Cow<'a, [TextRun]>) {
+        if max_lines <= 1 || truncate_from == TruncateFrom::Start {
+            return self.truncate_line(
+                text,
+                wrap_width * max_lines,
+                truncation_affix,
+                runs,
+                truncate_from,
+            );
+        }
+
+        let affix_width: Pixels = truncation_affix
+            .chars()
+            .map(|c| self.width_for_char(c))
+            .sum();
+
+        let mut width = px(0.);
+        let mut line = 0usize;
+        let mut first_non_whitespace_ix = None;
+        let mut last_candidate_ix = 0usize;
+        let mut last_candidate_width = px(0.);
+        let mut last_wrap_ix = 0usize;
+        let mut prev_c = '\0';
+        let mut indent: Option<u32> = None;
+        let mut truncate_ix = 0usize;
+
+        for (ix, c) in text.char_indices() {
+            if c == '\n' {
+                if line >= max_lines - 1 && !text[ix + 1..].trim().is_empty() {
+                    // Newline on the last allowed line with real content
+                    // below. Truncate here.
+                    let truncated = text[..truncate_ix]
+                        .trim_end_matches(|c: char| c.is_whitespace() || c.is_ascii_punctuation());
+                    let result = SharedString::from(format!("{truncated}{truncation_affix}"));
+                    let mut runs = runs.to_vec();
+                    update_runs_after_truncation(
+                        &result,
+                        truncation_affix,
+                        &mut runs,
+                        TruncateFrom::End,
+                    );
+                    return (result, Cow::Owned(runs));
+                }
+
+                // Newline before the last line: it consumes a line.
+                line += 1;
+                width = px(0.);
+                first_non_whitespace_ix = None;
+                last_candidate_ix = 0;
+                last_candidate_width = px(0.);
+                last_wrap_ix = ix + 1;
+                prev_c = '\0';
+                indent = None;
+                truncate_ix = ix + 1;
+                continue;
+            }
+
+            let char_width = self.width_for_char(c);
+
+            if Self::is_word_char(c) {
+                if prev_c == ' ' && first_non_whitespace_ix.is_some() {
+                    last_candidate_ix = ix;
+                    last_candidate_width = width;
+                }
+            } else if c != ' ' && first_non_whitespace_ix.is_some() {
+                last_candidate_ix = ix;
+                last_candidate_width = width;
+            }
+
+            if c != ' ' && first_non_whitespace_ix.is_none() {
+                first_non_whitespace_ix = Some(ix);
+            }
+
+            width += char_width;
+
+            if line < max_lines - 1 {
+                // Before the last line: replicate wrap_line's boundary logic.
+                if width > wrap_width && ix > last_wrap_ix {
+                    if let (None, Some(first_nw)) = (indent, first_non_whitespace_ix) {
+                        indent = Some(Self::MAX_INDENT.min((first_nw - last_wrap_ix) as u32));
+                    }
+
+                    if last_candidate_ix > last_wrap_ix {
+                        last_wrap_ix = last_candidate_ix;
+                        width -= last_candidate_width;
+                        last_candidate_ix = 0;
+                    } else {
+                        last_wrap_ix = ix;
+                        width = char_width;
+                    }
+
+                    if let Some(ind) = indent {
+                        width += self.width_for_char(' ') * ind as f32;
+                    }
+
+                    line += 1;
+                    truncate_ix = last_wrap_ix;
+                }
+            } else {
+                // On the last line: track the furthest point where the affix
+                // still fits, and stop as soon as the line overflows.
+                if width + affix_width <= wrap_width {
+                    truncate_ix = ix + c.len_utf8();
+                }
+
+                if width > wrap_width {
+                    let truncated = text[..truncate_ix]
+                        .trim_end_matches(|c: char| c.is_whitespace() || c.is_ascii_punctuation());
+                    let result = SharedString::from(format!("{truncated}{truncation_affix}"));
+                    let mut runs = runs.to_vec();
+                    update_runs_after_truncation(
+                        &result,
+                        truncation_affix,
+                        &mut runs,
+                        TruncateFrom::End,
+                    );
+                    return (result, Cow::Owned(runs));
+                }
+            }
+
+            prev_c = c;
+        }
+
+        // Text fits within max_lines without truncation.
+        (text, Cow::Borrowed(runs))
+    }
+
     /// Any character in this list should be treated as a word character,
     /// meaning it can be part of a word that should not be wrapped.
     pub(crate) fn is_word_char(c: char) -> bool {
@@ -938,4 +1082,251 @@ mod tests {
             );
         });
     }
+
+    #[test]
+    fn test_multiline_truncation_fits_within_wrapped_lines() {
+        let mut wrapper = build_wrapper();
+
+        // With .ZedMono at 16px, each char is 9.6px wide.
+        // wrap_width = 72px fits ~7 chars per line.
+        //
+        // "aa bbbbbb cccccc dddddd eeee ffff" with wrap_width=72px wraps as:
+        //   Line 1: "aa "       (28.8px, wraps because "bbbbbb" won't fit)
+        //   Line 2: "bbbbbb "   (67.2px)
+        //   Line 3: "cccccc "   (67.2px)
+        //   ...
+        //
+        // truncate_wrapped_line should wrap first to find line 2 starts at
+        // "bbbbbb...", then truncate only that line to fit with ellipsis.
+        let text: &str = "aa bbbbbb cccccc dddddd eeee ffff";
+        let wrap_width = px(72.);
+        let max_lines: usize = 2;
+
+        let runs = generate_test_runs(&[text.len()]);
+        let (truncated, _) = wrapper.truncate_wrapped_line(
+            text.into(),
+            wrap_width,
+            max_lines,
+            "\u{2026}",
+            &runs,
+            TruncateFrom::End,
+        );
+
+        // The truncated text, when wrapped, must fit within max_lines lines.
+        let wrap_count = wrapper
+            .wrap_line(&[LineFragment::text(&truncated)], wrap_width)
+            .count();
+
+        assert!(
+            wrap_count < max_lines,
+            "Truncated text '{}' wraps into {} visual lines, expected at most {}",
+            truncated,
+            wrap_count + 1,
+            max_lines
+        );
+
+        // The truncated text should end with the ellipsis.
+        assert!(
+            truncated.ends_with('\u{2026}'),
+            "Truncated text '{}' should end with ellipsis",
+            truncated
+        );
+    }
+
+    #[test]
+    fn test_multiline_truncation_no_truncation_needed() {
+        let mut wrapper = build_wrapper();
+
+        // Text that fits in 2 lines shouldn't be truncated.
+        // Line 1: "aa bbb " (67.2px), Line 2: "cccccc" (57.6px)
+        let text: &str = "aa bbb cccccc";
+        let wrap_width = px(72.);
+        let max_lines: usize = 2;
+
+        let runs = generate_test_runs(&[text.len()]);
+        let (result, _) = wrapper.truncate_wrapped_line(
+            text.into(),
+            wrap_width,
+            max_lines,
+            "\u{2026}",
+            &runs,
+            TruncateFrom::End,
+        );
+
+        assert_eq!(
+            result.as_ref(),
+            text,
+            "Text that fits should not be modified"
+        );
+    }
+
+    #[test]
+    fn test_multiline_truncation_three_lines() {
+        let mut wrapper = build_wrapper();
+
+        let text: &str = "aa bbb cccc ddddd eeee ffff gggg hhhh iiii jjjj";
+        let wrap_width = px(72.);
+        let max_lines: usize = 3;
+
+        let runs = generate_test_runs(&[text.len()]);
+        let (truncated, _) = wrapper.truncate_wrapped_line(
+            text.into(),
+            wrap_width,
+            max_lines,
+            "\u{2026}",
+            &runs,
+            TruncateFrom::End,
+        );
+
+        let wrap_count = wrapper
+            .wrap_line(&[LineFragment::text(&truncated)], wrap_width)
+            .count();
+
+        assert!(
+            wrap_count < max_lines,
+            "Truncated text '{}' wraps into {} visual lines, expected at most {}",
+            truncated,
+            wrap_count + 1,
+            max_lines
+        );
+
+        assert!(
+            truncated.ends_with('\u{2026}'),
+            "Truncated text '{}' should end with ellipsis",
+            truncated
+        );
+    }
+
+    #[test]
+    fn test_multiline_truncation_with_newlines() {
+        let mut wrapper = build_wrapper();
+
+        // "hello\nworld foo bar baz" with line_clamp(2):
+        // shape_text splits on \n, giving physical lines "hello" and
+        // "world foo bar baz". The newline consumes line 1, so the
+        // second physical line should be truncated on line 2.
+        let text: &str = "hello\nworld foo bar baz";
+        let wrap_width = px(72.);
+        let max_lines: usize = 2;
+
+        let runs = generate_test_runs(&[text.len()]);
+        let (truncated, _) = wrapper.truncate_wrapped_line(
+            text.into(),
+            wrap_width,
+            max_lines,
+            "\u{2026}",
+            &runs,
+            TruncateFrom::End,
+        );
+
+        // The newline should be preserved.
+        let parts: Vec<&str> = truncated.splitn(2, '\n').collect();
+        assert_eq!(
+            parts.len(),
+            2,
+            "Newline should be preserved: '{}'",
+            truncated
+        );
+        assert_eq!(parts[0], "hello");
+
+        // The second line should fit within wrap_width and end with ellipsis.
+        let second_line_width: Pixels = parts[1].chars().map(|c| wrapper.width_for_char(c)).sum();
+        assert!(
+            second_line_width <= wrap_width,
+            "Second line '{}' ({}px) exceeds wrap_width ({}px)",
+            parts[1],
+            second_line_width,
+            wrap_width
+        );
+        assert!(
+            truncated.ends_with('\u{2026}'),
+            "Should end with ellipsis: '{}'",
+            truncated
+        );
+    }
+
+    #[test]
+    fn test_multiline_truncation_newline_on_last_line() {
+        let mut wrapper = build_wrapper();
+
+        // "hello\nworld\nmore" with line_clamp(2):
+        // Line 1: "hello", Line 2: "world" — but there's a third line,
+        // so line 2 should be truncated with ellipsis.
+        let text: &str = "hello\nworld\nmore";
+        let wrap_width = px(72.);
+        let max_lines: usize = 2;
+
+        let runs = generate_test_runs(&[text.len()]);
+        let (truncated, _) = wrapper.truncate_wrapped_line(
+            text.into(),
+            wrap_width,
+            max_lines,
+            "\u{2026}",
+            &runs,
+            TruncateFrom::End,
+        );
+
+        let parts: Vec<&str> = truncated.splitn(2, '\n').collect();
+        assert_eq!(parts[0], "hello");
+        assert!(
+            truncated.ends_with('\u{2026}'),
+            "Should end with ellipsis since there's more content: '{}'",
+            truncated
+        );
+    }
+
+    #[test]
+    fn test_multiline_truncation_trailing_newline() {
+        let mut wrapper = build_wrapper();
+
+        // "hello\nworld\n" with line_clamp(2):
+        // The trailing newline has no content after it, so no ellipsis.
+        let text: &str = "hello\nworld\n";
+        let wrap_width = px(72.);
+        let max_lines: usize = 2;
+
+        let runs = generate_test_runs(&[text.len()]);
+        let (result, _) = wrapper.truncate_wrapped_line(
+            text.into(),
+            wrap_width,
+            max_lines,
+            "\u{2026}",
+            &runs,
+            TruncateFrom::End,
+        );
+
+        assert!(
+            !result.ends_with('\u{2026}'),
+            "Trailing newline with no content should not add ellipsis: '{}'",
+            result
+        );
+    }
+
+    #[test]
+    fn test_multiline_truncation_newline_fits_exactly() {
+        let mut wrapper = build_wrapper();
+
+        // "hello\nworld" with line_clamp(2):
+        // Exactly 2 lines, no truncation needed.
+        let text: &str = "hello\nworld";
+        let wrap_width = px(72.);
+        let max_lines: usize = 2;
+
+        let runs = generate_test_runs(&[text.len()]);
+        let (result, _) = wrapper.truncate_wrapped_line(
+            text.into(),
+            wrap_width,
+            max_lines,
+            "\u{2026}",
+            &runs,
+            TruncateFrom::End,
+        );
+
+        assert_eq!(
+            result.as_ref(),
+            text,
+            "Text that fits exactly should not be modified: '{}'",
+            result
+        );
+    }
 }

From 6753eb1736536abc020d690e803e5f51a8793bff Mon Sep 17 00:00:00 2001
From: MartinYe1234 <52641447+MartinYe1234@users.noreply.github.com>
Date: Thu, 21 May 2026 15:51:57 -0700
Subject: [PATCH 100/105] Update skill settings immediately after changes
 (#57447)

## Summary
- Hide deleted skills immediately in Settings while deletion completes
- Refresh the skill index after creating a skill so Settings updates
without reopening

Closes AI-299
Release Notes:

- Fixed skill management so newly created and deleted skills update in
Settings immediately.
---
 crates/agent/src/agent.rs                    | 10 +++
 crates/agent_ui/src/agent_panel.rs           | 32 ++++++++++
 crates/settings_ui/src/pages/skills_setup.rs | 64 ++++++++++++++------
 crates/settings_ui/src/settings_ui.rs        | 28 +++++++++
 crates/skill_creator/src/skill_creator.rs    | 12 +++-
 5 files changed, 128 insertions(+), 18 deletions(-)

diff --git a/crates/agent/src/agent.rs b/crates/agent/src/agent.rs
index f704e997ac0..8ef06de1649 100644
--- a/crates/agent/src/agent.rs
+++ b/crates/agent/src/agent.rs
@@ -1766,6 +1766,16 @@ impl NativeAgentConnection {
             .update(cx, |agent, cx| agent.ensure_skills_scan_started(cx));
     }
 
+    pub fn refresh_skills_for_project(&self, project: Entity<Project>, cx: &mut App) {
+        self.0.update(cx, |agent, cx| {
+            let project_id = agent.get_or_create_project_state(&project, cx);
+            agent.ensure_skills_scan_started(cx);
+            if let Some(state) = agent.projects.get_mut(&project_id) {
+                state.project_context_needs_refresh.send(()).ok();
+            }
+        });
+    }
+
     pub fn available_skills(
         &self,
         session_id: &acp::SessionId,
diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs
index f83025b7735..fb7441d186a 100644
--- a/crates/agent_ui/src/agent_panel.rs
+++ b/crates/agent_ui/src/agent_panel.rs
@@ -3070,10 +3070,42 @@ impl AgentPanel {
         _window: &mut Window,
         cx: &mut Context<Self>,
     ) {
+        let this = cx.weak_entity();
+        let on_saved = Rc::new(move |cx: &mut App| {
+            this.update(cx, |this, cx| {
+                if !this.has_open_project(cx) {
+                    return;
+                }
+
+                this.ensure_native_agent_connection(cx);
+                let Some(connect_task) = this.connection_store.update(cx, |store, cx| {
+                    store
+                        .entry(&Agent::NativeAgent)
+                        .map(|entry| entry.read(cx).wait_for_connection())
+                }) else {
+                    return;
+                };
+                let project = this.project.clone();
+                cx.spawn(async move |_this, cx| -> Result<()> {
+                    let connected = connect_task.await?;
+                    if let Some(native_connection) = connected
+                        .connection
+                        .downcast::<agent::NativeAgentConnection>()
+                    {
+                        cx.update(|cx| native_connection.refresh_skills_for_project(project, cx));
+                    }
+                    Ok(())
+                })
+                .detach_and_log_err(cx);
+            })
+            .ok();
+        });
+
         open_skill_creator(
             Some(self.workspace.clone()),
             self.language_registry.clone(),
             self.fs.clone(),
+            Some(on_saved),
             cx,
         )
         .detach_and_log_err(cx);
diff --git a/crates/settings_ui/src/pages/skills_setup.rs b/crates/settings_ui/src/pages/skills_setup.rs
index bce8b7e7f51..0208f7db47f 100644
--- a/crates/settings_ui/src/pages/skills_setup.rs
+++ b/crates/settings_ui/src/pages/skills_setup.rs
@@ -23,18 +23,26 @@ pub(crate) fn render_skills_setup_page(
             .map(|idx| idx.global_skills.clone())
             .unwrap_or_default(),
         SettingsUiFile::Project((worktree_id, _)) => {
-            let wt_id = usize::from(*worktree_id);
+            let worktree_id = usize::from(*worktree_id);
             skill_index
-                .and_then(|idx| {
-                    idx.project_skills
+                .and_then(|index| {
+                    index
+                        .project_skills
                         .iter()
-                        .find(|g| g.worktree_id.0 == wt_id)
-                        .map(|g| g.skills.clone())
+                        .find(|group| group.worktree_id.0 == worktree_id)
+                        .map(|group| group.skills.clone())
                 })
                 .unwrap_or_default()
         }
         _ => Vec::new(),
-    };
+    }
+    .into_iter()
+    .filter(|skill| {
+        !settings_window
+            .hidden_deleted_skill_directory_paths
+            .contains(&skill.directory_path)
+    })
+    .collect();
 
     v_flex()
         .id("skills-page")
@@ -129,20 +137,42 @@ fn render_skill_row(skill: &Skill, cx: &mut Context<SettingsWindow>) -> AnyEleme
                     .icon_size(IconSize::Small)
                     .tooltip(Tooltip::text("Delete Skill"))
                     .on_click(cx.listener(
-                        move |_this, _event, _window, cx| {
+                        move |settings_window, _event, _window, cx| {
                             let directory_path = directory_path.clone();
+                            if !settings_window
+                                .hidden_deleted_skill_directory_paths
+                                .insert(directory_path.clone())
+                            {
+                                return;
+                            }
+                            cx.notify();
+
                             let app_state = workspace::AppState::global(cx);
                             let fs = app_state.fs.clone();
-                            cx.spawn(async move |_this, _cx| {
-                                fs.remove_dir(
-                                    &directory_path,
-                                    RemoveOptions {
-                                        recursive: true,
-                                        ignore_if_not_exists: true,
-                                    },
-                                )
-                                .await
-                                .log_err();
+                            cx.spawn(async move |settings_window, cx| {
+                                let remove_result = fs
+                                    .remove_dir(
+                                        &directory_path,
+                                        RemoveOptions {
+                                            recursive: true,
+                                            ignore_if_not_exists: true,
+                                        },
+                                    )
+                                    .await;
+                                if let Err(error) = remove_result {
+                                    log::error!(
+                                        "failed to delete skill directory {}: {error:#}",
+                                        directory_path.display()
+                                    );
+                                    settings_window
+                                        .update(cx, |settings_window, cx| {
+                                            settings_window
+                                                .hidden_deleted_skill_directory_paths
+                                                .remove(&directory_path);
+                                            cx.notify();
+                                        })
+                                        .ok();
+                                }
                             })
                             .detach();
                         },
diff --git a/crates/settings_ui/src/settings_ui.rs b/crates/settings_ui/src/settings_ui.rs
index 08ac192c88b..2a49a95af2a 100644
--- a/crates/settings_ui/src/settings_ui.rs
+++ b/crates/settings_ui/src/settings_ui.rs
@@ -2,6 +2,7 @@ mod components;
 mod page_data;
 pub mod pages;
 
+use agent_skills::SkillIndex;
 use anyhow::{Context as _, Result};
 use editor::{Editor, EditorEvent};
 use futures::{StreamExt, channel::mpsc};
@@ -29,6 +30,7 @@ use std::{
     collections::{HashMap, HashSet},
     num::{NonZero, NonZeroU32},
     ops::Range,
+    path::PathBuf,
     rc::Rc,
     sync::{Arc, LazyLock, RwLock},
     time::Duration,
@@ -767,6 +769,7 @@ pub struct SettingsWindow {
     search_index: Option<Arc<SearchIndex>>,
     list_state: ListState,
     shown_errors: HashSet<String>,
+    pub(crate) hidden_deleted_skill_directory_paths: HashSet<PathBuf>,
     pub(crate) regex_validation_error: Option<String>,
     last_copied_link_path: Option<&'static str>,
 }
@@ -1542,6 +1545,28 @@ impl SettingsWindow {
         })
         .detach();
 
+        cx.observe_global_in::<SkillIndex>(window, |this, _window, cx| {
+            if let Some(skill_index) = cx.try_global::<SkillIndex>() {
+                this.hidden_deleted_skill_directory_paths
+                    .retain(|directory_path| {
+                        skill_index
+                            .global_skills
+                            .iter()
+                            .chain(
+                                skill_index
+                                    .project_skills
+                                    .iter()
+                                    .flat_map(|group| group.skills.iter()),
+                            )
+                            .any(|skill| skill.directory_path.as_path() == directory_path.as_path())
+                    });
+            } else {
+                this.hidden_deleted_skill_directory_paths.clear();
+            }
+            cx.notify();
+        })
+        .detach();
+
         cx.on_window_closed(|cx, _window_id| {
             if let Some(existing_window) = cx
                 .windows()
@@ -1689,6 +1714,7 @@ impl SettingsWindow {
                 .tab_stop(false),
             search_index: None,
             shown_errors: HashSet::default(),
+            hidden_deleted_skill_directory_paths: HashSet::default(),
             regex_validation_error: None,
             list_state,
             last_copied_link_path: None,
@@ -4548,6 +4574,7 @@ pub mod test {
                 search_index: None,
                 list_state: ListState::new(0, gpui::ListAlignment::Top, px(0.0)),
                 shown_errors: HashSet::default(),
+                hidden_deleted_skill_directory_paths: HashSet::default(),
                 regex_validation_error: None,
                 last_copied_link_path: None,
             }
@@ -4674,6 +4701,7 @@ pub mod test {
             search_index: None,
             list_state: ListState::new(0, gpui::ListAlignment::Top, px(0.0)),
             shown_errors: HashSet::default(),
+            hidden_deleted_skill_directory_paths: HashSet::default(),
             regex_validation_error: None,
             last_copied_link_path: None,
         };
diff --git a/crates/skill_creator/src/skill_creator.rs b/crates/skill_creator/src/skill_creator.rs
index 8a1ee24437d..b9365bbc34d 100644
--- a/crates/skill_creator/src/skill_creator.rs
+++ b/crates/skill_creator/src/skill_creator.rs
@@ -15,6 +15,7 @@ use platform_title_bar::PlatformTitleBar;
 use release_channel::ReleaseChannel;
 use settings::{ActionSequence, Settings};
 use std::path::PathBuf;
+use std::rc::Rc;
 use std::sync::Arc;
 use theme_settings::ThemeSettings;
 use ui::{
@@ -113,6 +114,7 @@ pub fn open_skill_creator(
     workspace: Option<WeakEntity<Workspace>>,
     language_registry: Arc<LanguageRegistry>,
     fs: Arc<dyn Fs>,
+    on_saved: Option<Rc<dyn Fn(&mut App)>>,
     cx: &mut App,
 ) -> Task<Result<WindowHandle<SkillCreator>>> {
     cx.spawn(async move |cx| {
@@ -161,7 +163,9 @@ pub fn open_skill_creator(
                     ..Default::default()
                 },
                 |window, cx| {
-                    cx.new(|cx| SkillCreator::new(workspace, language_registry, fs, window, cx))
+                    cx.new(|cx| {
+                        SkillCreator::new(workspace, language_registry, fs, on_saved, window, cx)
+                    })
                 },
             )
         })
@@ -173,6 +177,7 @@ pub struct SkillCreator {
     title_bar: Option<Entity<PlatformTitleBar>>,
     workspace: Option<WeakEntity<Workspace>>,
     fs: Arc<dyn Fs>,
+    on_saved: Option<Rc<dyn Fn(&mut App)>>,
     name_editor: Entity<InputField>,
     description_editor: Entity<InputField>,
     body_editor: Entity<Editor>,
@@ -198,6 +203,7 @@ impl SkillCreator {
         workspace: Option<WeakEntity<Workspace>>,
         language_registry: Arc<LanguageRegistry>,
         fs: Arc<dyn Fs>,
+        on_saved: Option<Rc<dyn Fn(&mut App)>>,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
@@ -321,6 +327,7 @@ impl SkillCreator {
             },
             workspace,
             fs,
+            on_saved,
             name_editor,
             description_editor,
             body_editor,
@@ -468,6 +475,9 @@ impl SkillCreator {
                 this.save_task = None;
                 match result {
                     Ok(path) => {
+                        if let Some(on_saved) = &this.on_saved {
+                            on_saved(cx);
+                        }
                         if let Some(workspace) = workspace.as_ref().and_then(|w| w.upgrade()) {
                             workspace.update(cx, |workspace, cx| {
                                 workspace.show_toast(

From 78749a4c2a137b7858afb101a97824496a32b513 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Thu, 21 May 2026 19:59:15 -0300
Subject: [PATCH 101/105] agent_skills: Update create-skill description
 (#57449)

This PR adds a slight update to the built-in `create-skill` skill.

Release Notes:

- N/A
---
 crates/agent_skills/builtin/create-skill/SKILL.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/agent_skills/builtin/create-skill/SKILL.md b/crates/agent_skills/builtin/create-skill/SKILL.md
index c5c76d80b8f..4728ca46714 100644
--- a/crates/agent_skills/builtin/create-skill/SKILL.md
+++ b/crates/agent_skills/builtin/create-skill/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: create-skill
-description: Helps users create new agent skills for Zed. Use this when a user wants to create a skill, asks about SKILL.md structure, or wants to package reusable agent instructions.
+description: Helps you create new agent skills for Zed. Use this to create a skill, ask about SKILLs.md, or package reusable agent instructions.
 ---
 
 # Creating a Zed Agent Skill

From 776b8304b1d68362c3e003b05013b55c371cf92d Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Thu, 21 May 2026 20:00:06 -0300
Subject: [PATCH 102/105] sidebar: Remove pending indicator from header when
 visiting project again (#57454)

Quick follow-up to https://github.com/zed-industries/zed/pull/57322. We
weren't removing the pending notification when re-visiting the project
that contains the pending thread (only while the project is still
collapsed, though).

Release Notes:

- N/A
---
 crates/sidebar/src/sidebar.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/crates/sidebar/src/sidebar.rs b/crates/sidebar/src/sidebar.rs
index b02beeeee0b..6eef1741927 100644
--- a/crates/sidebar/src/sidebar.rs
+++ b/crates/sidebar/src/sidebar.rs
@@ -1632,6 +1632,12 @@ impl Sidebar {
                         }
                     }
                 }
+
+                if is_active
+                    && let Some(ActiveEntry::Thread { thread_id, .. }) = self.active_entry.as_ref()
+                {
+                    notified_threads.remove(thread_id);
+                }
             }
 
             let has_visible_rows = !threads.is_empty() || !terminals.is_empty();

From da74e24a79df4c544a9ad8f06866d75538853bef Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Thu, 21 May 2026 20:00:30 -0300
Subject: [PATCH 103/105] skills_creator: Add some UI adjustments (#57452)

Tiny changes: improving keyboard nav by fixing the tab order, and
improving styles by making the dropdown take just the width of the label
instead of a fixed width.

Release Notes:

- N/A
---
 crates/skill_creator/src/skill_creator.rs | 25 ++++++++++-------------
 1 file changed, 11 insertions(+), 14 deletions(-)

diff --git a/crates/skill_creator/src/skill_creator.rs b/crates/skill_creator/src/skill_creator.rs
index b9365bbc34d..5c5317d96af 100644
--- a/crates/skill_creator/src/skill_creator.rs
+++ b/crates/skill_creator/src/skill_creator.rs
@@ -36,8 +36,8 @@ actions!(
 
 const NAME_FIELD_TAB_INDEX: isize = 1;
 const DESCRIPTION_FIELD_TAB_INDEX: isize = 2;
-const SCOPE_FIELD_TAB_INDEX: isize = 3;
-const DISABLE_MODEL_INVOCATION_TAB_INDEX: isize = 4;
+const DISABLE_MODEL_INVOCATION_TAB_INDEX: isize = 3;
+const SCOPE_FIELD_TAB_INDEX: isize = 4;
 const BODY_FIELD_TAB_INDEX: isize = 5;
 
 pub fn init(_cx: &mut App) {}
@@ -555,9 +555,7 @@ impl SkillCreator {
         };
 
         let selected_label = h_flex()
-            .min_w_0()
-            .w_full()
-            .child(Label::new(selected_label).truncate())
+            .child(Label::new(selected_label))
             .into_any_element();
 
         let weak = cx.weak_entity();
@@ -595,13 +593,11 @@ impl SkillCreator {
                     .child(Label::new(scope_hint).color(Color::Muted)),
             )
             .child(
-                div().w_1_3().min_w_0().child(
-                    DropdownMenu::new_with_element("skill-scope-dropdown", selected_label, menu)
-                        .tab_index(SCOPE_FIELD_TAB_INDEX)
-                        .style(DropdownStyle::Outlined)
-                        .trigger_size(ButtonSize::Medium)
-                        .full_width(true),
-                ),
+                DropdownMenu::new_with_element("skill-scope-dropdown", selected_label, menu)
+                    .tab_index(SCOPE_FIELD_TAB_INDEX)
+                    .style(DropdownStyle::Outlined)
+                    .trigger_size(ButtonSize::Medium)
+                    .full_width(false),
             )
     }
 
@@ -620,7 +616,8 @@ impl SkillCreator {
                 this.toggle_disable_model_invocation(cx);
             }),
         )
-        .tab_index(DISABLE_MODEL_INVOCATION_TAB_INDEX).into_any_element()
+        .tab_index(DISABLE_MODEL_INVOCATION_TAB_INDEX)
+        .into_any_element()
     }
 
     fn render_body_field(&self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
@@ -816,7 +813,7 @@ impl Render for SkillCreator {
                         .child(
                             v_flex()
                                 .gap_2()
-                                .child(Label::new("Font-matter"))
+                                .child(Label::new("Front-matter"))
                                 .child(self.name_editor.clone())
                                 .child(self.description_editor.clone()),
                         )

From d5cf9a65d293eb1680ab46ec98cb2908f53c12f0 Mon Sep 17 00:00:00 2001
From: MartinYe1234 <52641447+MartinYe1234@users.noreply.github.com>
Date: Thu, 21 May 2026 16:17:59 -0700
Subject: [PATCH 104/105] Fix skill creator remote project scopes (#57453)

Summary:

- Include remote worktrees as project-scope options in the skill
creator.
- Reuse workspace root path detection for project scope paths.

Validation:

- cargo check -p skill_creator
- cargo test -p skill_creator

Release Notes:

- Fixed project-local skill creation for remote projects.
---
 crates/skill_creator/src/skill_creator.rs | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/crates/skill_creator/src/skill_creator.rs b/crates/skill_creator/src/skill_creator.rs
index 5c5317d96af..e95fe876ef3 100644
--- a/crates/skill_creator/src/skill_creator.rs
+++ b/crates/skill_creator/src/skill_creator.rs
@@ -91,19 +91,17 @@ fn project_scopes_from_workspace(
         return Vec::new();
     };
     let workspace = workspace.read(cx);
-    let project = workspace.project().read(cx);
-    project
+    let root_paths = workspace.root_paths(cx);
+    workspace
         .visible_worktrees(cx)
-        .filter_map(|worktree| {
+        .zip(root_paths)
+        .map(|(worktree, abs_path)| {
             let worktree = worktree.read(cx);
-            if !worktree.is_local() {
-                return None;
-            }
-            Some(ScopeChoice::Project {
+            ScopeChoice::Project {
                 worktree_id: worktree.id(),
                 root_name: SharedString::from(worktree.root_name_str().to_string()),
-                abs_path: worktree.abs_path(),
-            })
+                abs_path,
+            }
         })
         .collect()
 }

From e2a1c4ce0c5dc8882d8e3290f148020896c8d380 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Thu, 21 May 2026 22:15:30 -0300
Subject: [PATCH 105/105] agent_ui: Remove count for user rules in context
 tooltip (#57456)

The circular progress in the agent panel's message editor would
previously display the number of default user rules auto-embedded into
the thread. However, given default rules are all migrated to a global
AGENTS.md file, that feature doesn't make a lot of sense anymore. So,
this PR fixes it by adding a button that opens up the global file when
it exists.

Release Notes:

- N/A
---
 .../src/conversation_view/thread_view.rs      | 79 ++++++++++---------
 1 file changed, 43 insertions(+), 36 deletions(-)

diff --git a/crates/agent_ui/src/conversation_view/thread_view.rs b/crates/agent_ui/src/conversation_view/thread_view.rs
index 43d850f8688..2203ec96e82 100644
--- a/crates/agent_ui/src/conversation_view/thread_view.rs
+++ b/crates/agent_ui/src/conversation_view/thread_view.rs
@@ -8,7 +8,7 @@ use agent_client_protocol::schema as acp;
 use std::cell::RefCell;
 
 use acp_thread::{ContentBlock, PlanEntry};
-use agent::{SkillLoadingError, SkillLoadingErrorsUpdated};
+use agent::{SkillLoadingError, SkillLoadingErrorsUpdated, UserAgentsMd};
 use cloud_api_types::{SubmitAgentThreadFeedbackBody, SubmitAgentThreadFeedbackCommentsBody};
 use editor::actions::OpenExcerpts;
 use feature_flags::AcpBetaFeatureFlag;
@@ -3632,12 +3632,10 @@ impl ThreadView {
 
         let tooltip_separator_color = Color::Custom(cx.theme().colors().text_disabled.opacity(0.6));
 
-        let (user_rules_count, first_user_rules_id, project_rules_count, project_entry_ids) = self
+        let (project_rules_count, project_entry_ids) = self
             .as_native_thread(cx)
             .map(|thread| {
                 let project_context = thread.read(cx).project_context().read(cx);
-                let user_rules_count = project_context.user_rules.len();
-                let first_user_rules_id = project_context.user_rules.first().map(|r| r.uuid.0);
                 let project_entry_ids = project_context
                     .worktrees
                     .iter()
@@ -3645,15 +3643,14 @@ impl ThreadView {
                     .map(|rf| ProjectEntryId::from_usize(rf.project_entry_id))
                     .collect::<Vec<_>>();
                 let project_rules_count = project_entry_ids.len();
-                (
-                    user_rules_count,
-                    first_user_rules_id,
-                    project_rules_count,
-                    project_entry_ids,
-                )
+                (project_rules_count, project_entry_ids)
             })
             .unwrap_or_default();
 
+        let global_agents_md_loaded = UserAgentsMd::global(cx)
+            .and_then(|md| md.content())
+            .is_some();
+
         let workspace = self.workspace.clone();
 
         let max_output_tokens = self
@@ -3688,8 +3685,7 @@ impl ThreadView {
                     show_split,
                     cost_label,
                     separator_color: tooltip_separator_color,
-                    user_rules_count,
-                    first_user_rules_id,
+                    global_agents_md_loaded,
                     project_rules_count,
                     project_entry_ids,
                     workspace,
@@ -4383,8 +4379,7 @@ struct TokenUsageTooltip {
     show_split: bool,
     cost_label: Option<String>,
     separator_color: Color,
-    user_rules_count: usize,
-    first_user_rules_id: Option<uuid::Uuid>,
+    global_agents_md_loaded: bool,
     project_rules_count: usize,
     project_entry_ids: Vec<ProjectEntryId>,
     workspace: WeakEntity<Workspace>,
@@ -4402,8 +4397,7 @@ impl Render for TokenUsageTooltip {
         let output_max = self.output_max.clone();
         let show_split = self.show_split;
         let cost_label = self.cost_label.clone();
-        let user_rules_count = self.user_rules_count;
-        let first_user_rules_id = self.first_user_rules_id;
+        let global_agents_md_loaded = self.global_agents_md_loaded;
         let project_rules_count = self.project_rules_count;
         let project_entry_ids = self.project_entry_ids.clone();
         let workspace = self.workspace.clone();
@@ -4466,7 +4460,7 @@ impl Render for TokenUsageTooltip {
                     )
                 })
                 .when(
-                    user_rules_count > 0 || project_rules_count > 0,
+                    global_agents_md_loaded || project_rules_count > 0,
                     move |this| {
                         this.child(
                             v_flex()
@@ -4484,26 +4478,39 @@ impl Render for TokenUsageTooltip {
                                 .child(
                                     v_flex()
                                         .mx_neg_1()
-                                        .when(user_rules_count > 0, move |this| {
-                                            this.child(
-                                                Button::new(
-                                                    "open-user-rules",
-                                                    format!("{} user rules", user_rules_count),
+                                        .when(global_agents_md_loaded, {
+                                            let workspace = workspace.clone();
+                                            move |this| {
+                                                this.child(
+                                                    Button::new(
+                                                        "open-global-agents-md",
+                                                        "1 global rule",
+                                                    )
+                                                    .end_icon(
+                                                        Icon::new(IconName::ArrowUpRight)
+                                                            .color(Color::Muted)
+                                                            .size(IconSize::XSmall),
+                                                    )
+                                                    .on_click(move |_, window, cx| {
+                                                        workspace
+                                                            .update(cx, |workspace, cx| {
+                                                                workspace
+                                                                    .open_abs_path(
+                                                                        paths::agents_file()
+                                                                            .clone(),
+                                                                        workspace::OpenOptions {
+                                                                            focus: Some(true),
+                                                                            ..Default::default()
+                                                                        },
+                                                                        window,
+                                                                        cx,
+                                                                    )
+                                                                    .detach_and_log_err(cx);
+                                                            })
+                                                            .log_err();
+                                                    }),
                                                 )
-                                                .end_icon(
-                                                    Icon::new(IconName::ArrowUpRight)
-                                                        .color(Color::Muted)
-                                                        .size(IconSize::XSmall),
-                                                )
-                                                .on_click(move |_, window, cx| {
-                                                    window.dispatch_action(
-                                                        Box::new(OpenRulesLibrary {
-                                                            prompt_to_select: first_user_rules_id,
-                                                        }),
-                                                        cx,
-                                                    );
-                                                }),
-                                            )
+                                            }
                                         })
                                         .when(project_rules_count > 0, move |this| {
                                             let workspace = workspace.clone();