wip

switch from action to event
wip: start adding action
2025-07-22 14:08:11 -07:00 · 2025-07-18 14:34:31 -07:00 · 2025-07-18 14:34:31 -07:00 · 2025-07-18 14:34:31 -07:00 · 2025-07-11 16:24:41 +00:00 · 2025-07-11 13:15:06 -03:00
33 changed files with 1466 additions and 389 deletions
--- a/.zed/settings.json
+++ b/.zed/settings.json
@@ -40,7 +40,7 @@
  },
  "file_types": {
    "Dockerfile": ["Dockerfile*[!dockerignore]"],
-    "JSONC": ["assets/**/*.json", "renovate.json"],
+    "JSONC": ["**/assets/**/*.json", "renovate.json"],
    "Git Ignore": ["dockerignore"]
  },
  "hard_tabs": false,
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9,6 +9,7 @@ dependencies = [
 "agent_servers",
 "agentic-coding-protocol",
 "anyhow",
+ "assistant_tool",
 "async-pipe",
 "buffer_diff",
 "editor",
@@ -263,9 +264,9 @@ dependencies = [

 [[package]]
 name = "agentic-coding-protocol"
-version = "0.0.6"
+version = "0.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1ac0351749af7bf53c65042ef69fefb9351aa8b7efa0a813d6281377605c37d"
+checksum = "a75f520bcc049ebe40c8c99427aa61b48ad78a01bcc96a13b350b903dcfb9438"
 dependencies = [
 "anyhow",
 "chrono",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -404,7 +404,7 @@ zlog_settings = { path = "crates/zlog_settings" }
 # External crates
 #

-agentic-coding-protocol = "0.0.6"
+agentic-coding-protocol = "0.0.7"
 aho-corasick = "1.1"
 alacritty_terminal = { git = "https://github.com/zed-industries/alacritty.git", branch = "add-hush-login-flag" }
 any_vec = "0.14"
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -320,7 +320,8 @@
    "bindings": {
      "enter": "agent::Chat",
      "up": "agent::PreviousHistoryMessage",
-      "down": "agent::NextHistoryMessage"
+      "down": "agent::NextHistoryMessage",
+      "shift-ctrl-r": "agent::OpenAgentDiff"
    }
  },
  {
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -371,7 +371,8 @@
    "bindings": {
      "enter": "agent::Chat",
      "up": "agent::PreviousHistoryMessage",
-      "down": "agent::NextHistoryMessage"
+      "down": "agent::NextHistoryMessage",
+      "shift-ctrl-r": "agent::OpenAgentDiff"
    }
  },
  {
--- a/crates/acp/Cargo.toml
+++ b/crates/acp/Cargo.toml
@@ -20,6 +20,7 @@ gemini = []
 agent_servers.workspace = true
 agentic-coding-protocol.workspace = true
 anyhow.workspace = true
+assistant_tool.workspace = true
 buffer_diff.workspace = true
 editor.workspace = true
 futures.workspace = true
--- a/crates/acp/src/acp.rs
+++ b/crates/acp/src/acp.rs
@@ -2,14 +2,19 @@ pub use acp::ToolCallId;
 use agent_servers::AgentServer;
 use agentic_coding_protocol::{self as acp, UserMessageChunk};
 use anyhow::{Context as _, Result, anyhow};
+use assistant_tool::ActionLog;
 use buffer_diff::BufferDiff;
 use editor::{MultiBuffer, PathKey};
 use futures::{FutureExt, channel::oneshot, future::BoxFuture};
 use gpui::{AppContext, AsyncApp, Context, Entity, EventEmitter, SharedString, Task, WeakEntity};
 use itertools::Itertools;
-use language::{Anchor, Buffer, Capability, LanguageRegistry, OffsetRangeExt as _};
+use language::{
+    Anchor, Buffer, BufferSnapshot, Capability, LanguageRegistry, OffsetRangeExt as _, Point,
+    text_diff,
+};
 use markdown::Markdown;
-use project::Project;
+use project::{AgentLocation, Project};
+use std::collections::HashMap;
 use std::error::Error;
 use std::fmt::{Formatter, Write};
 use std::{
@@ -159,6 +164,18 @@ impl AgentThreadEntry {
            Self::ToolCall(too_call) => too_call.to_markdown(cx),
        }
    }
+
+    pub fn diff(&self) -> Option<&Diff> {
+        if let AgentThreadEntry::ToolCall(ToolCall {
+            content: Some(ToolCallContent::Diff { diff }),
+            ..
+        }) = self
+        {
+            Some(&diff)
+        } else {
+            None
+        }
+    }
 }

 #[derive(Debug)]
@@ -168,6 +185,7 @@ pub struct ToolCall {
    pub icon: IconName,
    pub content: Option<ToolCallContent>,
    pub status: ToolCallStatus,
+    pub locations: Vec<acp::ToolCallLocation>,
 }

 impl ToolCall {
@@ -328,6 +346,8 @@ impl ToolCallContent {
 pub struct Diff {
    pub multibuffer: Entity<MultiBuffer>,
    pub path: PathBuf,
+    pub new_buffer: Entity<Buffer>,
+    pub old_buffer: Entity<Buffer>,
    _task: Task<Result<()>>,
 }

@@ -362,6 +382,7 @@ impl Diff {
        let task = cx.spawn({
            let multibuffer = multibuffer.clone();
            let path = path.clone();
+            let new_buffer = new_buffer.clone();
            async move |cx| {
                diff_task.await?;

@@ -401,6 +422,8 @@ impl Diff {
        Self {
            multibuffer,
            path,
+            new_buffer,
+            old_buffer,
            _task: task,
        }
    }
@@ -421,6 +444,8 @@ pub struct AcpThread {
    entries: Vec<AgentThreadEntry>,
    title: SharedString,
    project: Entity<Project>,
+    action_log: Entity<ActionLog>,
+    shared_buffers: HashMap<Entity<Buffer>, BufferSnapshot>,
    send_task: Option<Task<()>>,
    connection: Arc<acp::AgentConnection>,
    child_status: Option<Task<Result<()>>>,
@@ -522,7 +547,11 @@ impl AcpThread {
                }
            });

+            let action_log = cx.new(|_| ActionLog::new(project.clone()));
+
            Self {
+                action_log,
+                shared_buffers: Default::default(),
                entries: Default::default(),
                title: "ACP Thread".into(),
                project,
@@ -534,6 +563,14 @@ impl AcpThread {
        })
    }

+    pub fn action_log(&self) -> &Entity<ActionLog> {
+        &self.action_log
+    }
+
+    pub fn project(&self) -> &Entity<Project> {
+        &self.project
+    }
+
    #[cfg(test)]
    pub fn fake(
        stdin: async_pipe::PipeWriter,
@@ -558,7 +595,11 @@ impl AcpThread {
            }
        });

+        let action_log = cx.new(|_| ActionLog::new(project.clone()));
+
        Self {
+            action_log,
+            shared_buffers: Default::default(),
            entries: Default::default(),
            title: "ACP Thread".into(),
            project,
@@ -589,6 +630,26 @@ impl AcpThread {
        }
    }

+    pub fn has_pending_edit_tool_calls(&self) -> bool {
+        for entry in self.entries.iter().rev() {
+            match entry {
+                AgentThreadEntry::UserMessage(_) => return false,
+                AgentThreadEntry::ToolCall(ToolCall {
+                    status:
+                        ToolCallStatus::Allowed {
+                            status: acp::ToolCallStatus::Running,
+                            ..
+                        },
+                    content: Some(ToolCallContent::Diff { .. }),
+                    ..
+                }) => return true,
+                AgentThreadEntry::ToolCall(_) | AgentThreadEntry::AssistantMessage(_) => {}
+            }
+        }
+
+        false
+    }
+
    pub fn push_entry(&mut self, entry: AgentThreadEntry, cx: &mut Context<Self>) {
        self.entries.push(entry);
        cx.emit(AcpThreadEvent::NewEntry);
@@ -644,65 +705,63 @@ impl AcpThread {

    pub fn request_tool_call(
        &mut self,
-        label: String,
-        icon: acp::Icon,
-        content: Option<acp::ToolCallContent>,
-        confirmation: acp::ToolCallConfirmation,
+        tool_call: acp::RequestToolCallConfirmationParams,
        cx: &mut Context<Self>,
    ) -> ToolCallRequest {
        let (tx, rx) = oneshot::channel();

        let status = ToolCallStatus::WaitingForConfirmation {
            confirmation: ToolCallConfirmation::from_acp(
-                confirmation,
+                tool_call.confirmation,
                self.project.read(cx).languages().clone(),
                cx,
            ),
            respond_tx: tx,
        };

-        let id = self.insert_tool_call(label, status, icon, content, cx);
+        let id = self.insert_tool_call(tool_call.tool_call, status, cx);
        ToolCallRequest { id, outcome: rx }
    }

    pub fn push_tool_call(
        &mut self,
-        label: String,
-        icon: acp::Icon,
-        content: Option<acp::ToolCallContent>,
+        request: acp::PushToolCallParams,
        cx: &mut Context<Self>,
    ) -> acp::ToolCallId {
        let status = ToolCallStatus::Allowed {
            status: acp::ToolCallStatus::Running,
        };

-        self.insert_tool_call(label, status, icon, content, cx)
+        self.insert_tool_call(request, status, cx)
    }

    fn insert_tool_call(
        &mut self,
-        label: String,
+        tool_call: acp::PushToolCallParams,
        status: ToolCallStatus,
-        icon: acp::Icon,
-        content: Option<acp::ToolCallContent>,
        cx: &mut Context<Self>,
    ) -> acp::ToolCallId {
        let language_registry = self.project.read(cx).languages().clone();
        let id = acp::ToolCallId(self.entries.len() as u64);
-
-        self.push_entry(
-            AgentThreadEntry::ToolCall(ToolCall {
-                id,
-                label: cx.new(|cx| {
-                    Markdown::new(label.into(), Some(language_registry.clone()), None, cx)
-                }),
-                icon: acp_icon_to_ui_icon(icon),
-                content: content
-                    .map(|content| ToolCallContent::from_acp(content, language_registry, cx)),
-                status,
+        let call = ToolCall {
+            id,
+            label: cx.new(|cx| {
+                Markdown::new(
+                    tool_call.label.into(),
+                    Some(language_registry.clone()),
+                    None,
+                    cx,
+                )
            }),
-            cx,
-        );
+            icon: acp_icon_to_ui_icon(tool_call.icon),
+            content: tool_call
+                .content
+                .map(|content| ToolCallContent::from_acp(content, language_registry, cx)),
+            locations: tool_call.locations,
+            status,
+        };
+
+        self.push_entry(AgentThreadEntry::ToolCall(call), cx);

        id
    }
@@ -804,14 +863,16 @@ impl AcpThread {
        false
    }

-    pub fn initialize(&self) -> impl use<> + Future<Output = Result<acp::InitializeResponse>> {
+    pub fn initialize(
+        &self,
+    ) -> impl use<> + Future<Output = Result<acp::InitializeResponse, acp::Error>> {
        let connection = self.connection.clone();
-        async move { Ok(connection.request(acp::InitializeParams).await?) }
+        async move { connection.request(acp::InitializeParams).await }
    }

-    pub fn authenticate(&self) -> impl use<> + Future<Output = Result<()>> {
+    pub fn authenticate(&self) -> impl use<> + Future<Output = Result<(), acp::Error>> {
        let connection = self.connection.clone();
-        async move { Ok(connection.request(acp::AuthenticateParams).await?) }
+        async move { connection.request(acp::AuthenticateParams).await }
    }

    #[cfg(test)]
@@ -819,7 +880,7 @@ impl AcpThread {
        &mut self,
        message: &str,
        cx: &mut Context<Self>,
-    ) -> BoxFuture<'static, Result<()>> {
+    ) -> BoxFuture<'static, Result<(), acp::Error>> {
        self.send(
            acp::SendUserMessageParams {
                chunks: vec![acp::UserMessageChunk::Text {
@@ -834,7 +895,7 @@ impl AcpThread {
        &mut self,
        message: acp::SendUserMessageParams,
        cx: &mut Context<Self>,
-    ) -> BoxFuture<'static, Result<()>> {
+    ) -> BoxFuture<'static, Result<(), acp::Error>> {
        let agent = self.connection.clone();
        self.push_entry(
            AgentThreadEntry::UserMessage(UserMessage::from_acp(
@@ -865,7 +926,7 @@ impl AcpThread {
        .boxed()
    }

-    pub fn cancel(&mut self, cx: &mut Context<Self>) -> Task<Result<()>> {
+    pub fn cancel(&mut self, cx: &mut Context<Self>) -> Task<Result<(), acp::Error>> {
        let agent = self.connection.clone();

        if self.send_task.take().is_some() {
@@ -898,13 +959,123 @@ impl AcpThread {
                            }
                        }
                    }
-                })
+                })?;
+                Ok(())
            })
        } else {
            Task::ready(Ok(()))
        }
    }

+    pub fn read_text_file(
+        &self,
+        request: acp::ReadTextFileParams,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<String>> {
+        let project = self.project.clone();
+        let action_log = self.action_log.clone();
+        cx.spawn(async move |this, cx| {
+            let load = project.update(cx, |project, cx| {
+                let path = project
+                    .project_path_for_absolute_path(&request.path, cx)
+                    .context("invalid path")?;
+                anyhow::Ok(project.open_buffer(path, cx))
+            });
+            let buffer = load??.await?;
+
+            action_log.update(cx, |action_log, cx| {
+                action_log.buffer_read(buffer.clone(), cx);
+            })?;
+            project.update(cx, |project, cx| {
+                let position = buffer
+                    .read(cx)
+                    .snapshot()
+                    .anchor_before(Point::new(request.line.unwrap_or_default(), 0));
+                project.set_agent_location(
+                    Some(AgentLocation {
+                        buffer: buffer.downgrade(),
+                        position,
+                    }),
+                    cx,
+                );
+            })?;
+            let snapshot = buffer.update(cx, |buffer, _| buffer.snapshot())?;
+            this.update(cx, |this, _| {
+                let text = snapshot.text();
+                this.shared_buffers.insert(buffer.clone(), snapshot);
+                text
+            })
+        })
+    }
+
+    pub fn write_text_file(
+        &self,
+        path: PathBuf,
+        content: String,
+        cx: &mut Context<Self>,
+    ) -> Task<Result<()>> {
+        let project = self.project.clone();
+        let action_log = self.action_log.clone();
+        cx.spawn(async move |this, cx| {
+            let load = project.update(cx, |project, cx| {
+                let path = project
+                    .project_path_for_absolute_path(&path, cx)
+                    .context("invalid path")?;
+                anyhow::Ok(project.open_buffer(path, cx))
+            });
+            let buffer = load??.await?;
+            let snapshot = this.update(cx, |this, cx| {
+                this.shared_buffers
+                    .get(&buffer)
+                    .cloned()
+                    .unwrap_or_else(|| buffer.read(cx).snapshot())
+            })?;
+            let edits = cx
+                .background_executor()
+                .spawn(async move {
+                    let old_text = snapshot.text();
+                    text_diff(old_text.as_str(), &content)
+                        .into_iter()
+                        .map(|(range, replacement)| {
+                            (
+                                snapshot.anchor_after(range.start)
+                                    ..snapshot.anchor_before(range.end),
+                                replacement,
+                            )
+                        })
+                        .collect::<Vec<_>>()
+                })
+                .await;
+            cx.update(|cx| {
+                project.update(cx, |project, cx| {
+                    project.set_agent_location(
+                        Some(AgentLocation {
+                            buffer: buffer.downgrade(),
+                            position: edits
+                                .last()
+                                .map(|(range, _)| range.end)
+                                .unwrap_or(Anchor::MIN),
+                        }),
+                        cx,
+                    );
+                });
+
+                action_log.update(cx, |action_log, cx| {
+                    action_log.buffer_read(buffer.clone(), cx);
+                });
+                buffer.update(cx, |buffer, cx| {
+                    buffer.edit(edits, None, cx);
+                });
+                action_log.update(cx, |action_log, cx| {
+                    action_log.buffer_edited(buffer.clone(), cx);
+                });
+            })?;
+            project
+                .update(cx, |project, cx| project.save_buffer(buffer, cx))?
+                .await
+        })
+    }
+
    pub fn child_status(&mut self) -> Option<Task<Result<()>>> {
        self.child_status.take()
    }
@@ -930,7 +1101,7 @@ impl acp::Client for AcpClientDelegate {
    async fn stream_assistant_message_chunk(
        &self,
        params: acp::StreamAssistantMessageChunkParams,
-    ) -> Result<()> {
+    ) -> Result<(), acp::Error> {
        let cx = &mut self.cx.clone();

        cx.update(|cx| {
@@ -947,45 +1118,37 @@ impl acp::Client for AcpClientDelegate {
    async fn request_tool_call_confirmation(
        &self,
        request: acp::RequestToolCallConfirmationParams,
-    ) -> Result<acp::RequestToolCallConfirmationResponse> {
+    ) -> Result<acp::RequestToolCallConfirmationResponse, acp::Error> {
        let cx = &mut self.cx.clone();
        let ToolCallRequest { id, outcome } = cx
            .update(|cx| {
-                self.thread.update(cx, |thread, cx| {
-                    thread.request_tool_call(
-                        request.label,
-                        request.icon,
-                        request.content,
-                        request.confirmation,
-                        cx,
-                    )
-                })
+                self.thread
+                    .update(cx, |thread, cx| thread.request_tool_call(request, cx))
            })?
            .context("Failed to update thread")?;

        Ok(acp::RequestToolCallConfirmationResponse {
            id,
-            outcome: outcome.await?,
+            outcome: outcome.await.map_err(acp::Error::into_internal_error)?,
        })
    }

    async fn push_tool_call(
        &self,
        request: acp::PushToolCallParams,
-    ) -> Result<acp::PushToolCallResponse> {
+    ) -> Result<acp::PushToolCallResponse, acp::Error> {
        let cx = &mut self.cx.clone();
        let id = cx
            .update(|cx| {
-                self.thread.update(cx, |thread, cx| {
-                    thread.push_tool_call(request.label, request.icon, request.content, cx)
-                })
+                self.thread
+                    .update(cx, |thread, cx| thread.push_tool_call(request, cx))
            })?
            .context("Failed to update thread")?;

        Ok(acp::PushToolCallResponse { id })
    }

-    async fn update_tool_call(&self, request: acp::UpdateToolCallParams) -> Result<()> {
+    async fn update_tool_call(&self, request: acp::UpdateToolCallParams) -> Result<(), acp::Error> {
        let cx = &mut self.cx.clone();

        cx.update(|cx| {
@@ -997,6 +1160,34 @@ impl acp::Client for AcpClientDelegate {

        Ok(())
    }
+
+    async fn read_text_file(
+        &self,
+        request: acp::ReadTextFileParams,
+    ) -> Result<acp::ReadTextFileResponse, acp::Error> {
+        let content = self
+            .cx
+            .update(|cx| {
+                self.thread
+                    .update(cx, |thread, cx| thread.read_text_file(request, cx))
+            })?
+            .context("Failed to update thread")?
+            .await?;
+        Ok(acp::ReadTextFileResponse { content })
+    }
+
+    async fn write_text_file(&self, request: acp::WriteTextFileParams) -> Result<(), acp::Error> {
+        self.cx
+            .update(|cx| {
+                self.thread.update(cx, |thread, cx| {
+                    thread.write_text_file(request.path, request.content, cx)
+                })
+            })?
+            .context("Failed to update thread")?
+            .await?;
+
+        Ok(())
+    }
 }

 fn acp_icon_to_ui_icon(icon: acp::Icon) -> IconName {
@@ -1100,6 +1291,80 @@ mod tests {
        );
    }

+    #[gpui::test]
+    async fn test_edits_concurrently_to_user(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        fs.insert_tree(path!("/tmp"), json!({"foo": "one\ntwo\nthree\n"}))
+            .await;
+        let project = Project::test(fs.clone(), [], cx).await;
+        let (thread, fake_server) = fake_acp_thread(project.clone(), cx);
+        let (worktree, pathbuf) = project
+            .update(cx, |project, cx| {
+                project.find_or_create_worktree(path!("/tmp/foo"), true, cx)
+            })
+            .await
+            .unwrap();
+        let buffer = project
+            .update(cx, |project, cx| {
+                project.open_buffer((worktree.read(cx).id(), pathbuf), cx)
+            })
+            .await
+            .unwrap();
+
+        let (read_file_tx, read_file_rx) = oneshot::channel::<()>();
+        let read_file_tx = Rc::new(RefCell::new(Some(read_file_tx)));
+
+        fake_server.update(cx, |fake_server, _| {
+            fake_server.on_user_message(move |_, server, mut cx| {
+                let read_file_tx = read_file_tx.clone();
+                async move {
+                    let content = server
+                        .update(&mut cx, |server, _| {
+                            server.send_to_zed(acp::ReadTextFileParams {
+                                path: path!("/tmp/foo").into(),
+                                line: None,
+                                limit: None,
+                            })
+                        })?
+                        .await
+                        .unwrap();
+                    assert_eq!(content.content, "one\ntwo\nthree\n");
+                    read_file_tx.take().unwrap().send(()).unwrap();
+                    server
+                        .update(&mut cx, |server, _| {
+                            server.send_to_zed(acp::WriteTextFileParams {
+                                path: path!("/tmp/foo").into(),
+                                content: "one\ntwo\nthree\nfour\nfive\n".to_string(),
+                            })
+                        })?
+                        .await
+                        .unwrap();
+                    Ok(())
+                }
+            })
+        });
+
+        let request = thread.update(cx, |thread, cx| {
+            thread.send_raw("Extend the count in /tmp/foo", cx)
+        });
+        read_file_rx.await.ok();
+        buffer.update(cx, |buffer, cx| {
+            buffer.edit([(0..0, "zero\n".to_string())], None, cx);
+        });
+        cx.run_until_parked();
+        assert_eq!(
+            buffer.read_with(cx, |buffer, _| buffer.text()),
+            "zero\none\ntwo\nthree\nfour\nfive\n"
+        );
+        assert_eq!(
+            String::from_utf8(fs.read_file_sync(path!("/tmp/foo")).unwrap()).unwrap(),
+            "zero\none\ntwo\nthree\nfour\nfive\n"
+        );
+        request.await.unwrap();
+    }
+
    #[gpui::test]
    async fn test_succeeding_canceled_toolcall(cx: &mut TestAppContext) {
        init_test(cx);
@@ -1124,6 +1389,7 @@ mod tests {
                                label: "Fetch".to_string(),
                                icon: acp::Icon::Globe,
                                content: None,
+                                locations: vec![],
                            })
                        })?
                        .await
@@ -1553,7 +1819,7 @@ mod tests {
                    acp::SendUserMessageParams,
                    Entity<FakeAcpServer>,
                    AsyncApp,
-                ) -> LocalBoxFuture<'static, Result<()>>,
+                ) -> LocalBoxFuture<'static, Result<(), acp::Error>>,
            >,
        >,
    }
@@ -1565,21 +1831,24 @@ mod tests {
    }

    impl acp::Agent for FakeAgent {
-        async fn initialize(&self) -> Result<acp::InitializeResponse> {
+        async fn initialize(&self) -> Result<acp::InitializeResponse, acp::Error> {
            Ok(acp::InitializeResponse {
                is_authenticated: true,
            })
        }

-        async fn authenticate(&self) -> Result<()> {
+        async fn authenticate(&self) -> Result<(), acp::Error> {
            Ok(())
        }

-        async fn cancel_send_message(&self) -> Result<()> {
+        async fn cancel_send_message(&self) -> Result<(), acp::Error> {
            Ok(())
        }

-        async fn send_user_message(&self, request: acp::SendUserMessageParams) -> Result<()> {
+        async fn send_user_message(
+            &self,
+            request: acp::SendUserMessageParams,
+        ) -> Result<(), acp::Error> {
            let mut cx = self.cx.clone();
            let handler = self
                .server
@@ -1589,7 +1858,7 @@ mod tests {
            if let Some(handler) = handler {
                handler(request, self.server.clone(), self.cx.clone()).await
            } else {
-                anyhow::bail!("No handler for on_user_message")
+                Err(anyhow::anyhow!("No handler for on_user_message").into())
            }
        }
    }
@@ -1624,7 +1893,7 @@ mod tests {
            handler: impl for<'a> Fn(acp::SendUserMessageParams, Entity<FakeAcpServer>, AsyncApp) -> F
            + 'static,
        ) where
-            F: Future<Output = Result<()>> + 'static,
+            F: Future<Output = Result<(), acp::Error>> + 'static,
        {
            self.on_user_message
                .replace(Rc::new(move |request, server, cx| {
--- a/crates/agent_ui/src/acp.rs
+++ b/crates/agent_ui/src/acp.rs
@@ -2,4 +2,5 @@ mod completion_provider;
 mod message_history;
 mod thread_view;

+pub use message_history::MessageHistory;
 pub use thread_view::AcpThreadView;
--- a/crates/agent_ui/src/acp/message_history.rs
+++ b/crates/agent_ui/src/acp/message_history.rs
@@ -3,19 +3,25 @@ pub struct MessageHistory<T> {
    current: Option<usize>,
 }

-impl<T> MessageHistory<T> {
-    pub fn new() -> Self {
+impl<T> Default for MessageHistory<T> {
+    fn default() -> Self {
        MessageHistory {
            items: Vec::new(),
            current: None,
        }
    }
+}

+impl<T> MessageHistory<T> {
    pub fn push(&mut self, message: T) {
        self.current.take();
        self.items.push(message);
    }

+    pub fn reset_position(&mut self) {
+        self.current.take();
+    }
+
    pub fn prev(&mut self) -> Option<&T> {
        if self.items.is_empty() {
            return None;
@@ -46,7 +52,7 @@ mod tests {

    #[test]
    fn test_prev_next() {
-        let mut history = MessageHistory::new();
+        let mut history = MessageHistory::default();

        // Test empty history
        assert_eq!(history.prev(), None);
--- a/crates/agent_ui/src/acp/thread_view.rs
+++ b/crates/agent_ui/src/acp/thread_view.rs
@@ -1,33 +1,38 @@
+use std::cell::RefCell;
+use std::collections::BTreeMap;
 use std::path::Path;
 use std::rc::Rc;
 use std::sync::Arc;
 use std::time::Duration;

 use agentic_coding_protocol::{self as acp};
+use assistant_tool::ActionLog;
+use buffer_diff::BufferDiff;
 use collections::{HashMap, HashSet};
 use editor::{
    AnchorRangeExt, ContextMenuOptions, ContextMenuPlacement, Editor, EditorElement, EditorMode,
-    EditorStyle, MinimapVisibility, MultiBuffer,
+    EditorStyle, MinimapVisibility, MultiBuffer, PathKey,
 };
 use file_icons::FileIcons;
 use futures::channel::oneshot;
 use gpui::{
-    Animation, AnimationExt, App, BorderStyle, EdgesRefinement, Empty, Entity, EntityId, Focusable,
-    Hsla, Length, ListOffset, ListState, SharedString, StyleRefinement, Subscription, TextStyle,
-    TextStyleRefinement, Transformation, UnderlineStyle, WeakEntity, Window, div, list, percentage,
-    prelude::*, pulsating_between,
+    Action, Animation, AnimationExt, App, BorderStyle, EdgesRefinement, Empty, Entity, EntityId,
+    FocusHandle, Focusable, Hsla, Length, ListOffset, ListState, SharedString, StyleRefinement,
+    Subscription, Task, TextStyle, TextStyleRefinement, Transformation, UnderlineStyle, WeakEntity,
+    Window, div, linear_color_stop, linear_gradient, list, percentage, point, prelude::*,
+    pulsating_between,
 };
-use gpui::{FocusHandle, Task};
 use language::language_settings::SoftWrap;
 use language::{Buffer, Language};
 use markdown::{HeadingLevelStyles, Markdown, MarkdownElement, MarkdownStyle};
 use parking_lot::Mutex;
 use project::Project;
 use settings::Settings as _;
+use text::Anchor;
 use theme::ThemeSettings;
-use ui::{Disclosure, Tooltip, prelude::*};
+use ui::{Disclosure, Divider, DividerColor, KeyBinding, Tooltip, prelude::*};
 use util::ResultExt;
-use workspace::Workspace;
+use workspace::{CollaboratorId, Workspace};
 use zed_actions::agent::{Chat, NextHistoryMessage, PreviousHistoryMessage};

 use ::acp::{
@@ -38,6 +43,8 @@ use ::acp::{

 use crate::acp::completion_provider::{ContextPickerCompletionProvider, MentionSet};
 use crate::acp::message_history::MessageHistory;
+use crate::agent_diff::AgentDiff;
+use crate::{AgentDiffPane, Follow, KeepAll, OpenAgentDiff, RejectAll};

 const RESPONSE_PADDING_X: Pixels = px(19.);

@@ -47,13 +54,16 @@ pub struct AcpThreadView {
    thread_state: ThreadState,
    diff_editors: HashMap<EntityId, Entity<Editor>>,
    message_editor: Entity<Editor>,
+    message_set_from_history: bool,
+    _message_editor_subscription: Subscription,
    mention_set: Arc<Mutex<MentionSet>>,
    last_error: Option<Entity<Markdown>>,
    list_state: ListState,
    auth_task: Option<Task<()>>,
    expanded_tool_calls: HashSet<ToolCallId>,
    expanded_thinking_blocks: HashSet<(usize, usize)>,
-    message_history: MessageHistory<acp::SendUserMessageParams>,
+    edits_expanded: bool,
+    message_history: Rc<RefCell<MessageHistory<acp::SendUserMessageParams>>>,
 }

 enum ThreadState {
@@ -62,7 +72,7 @@ enum ThreadState {
    },
    Ready {
        thread: Entity<AcpThread>,
-        _subscription: Subscription,
+        _subscription: [Subscription; 2],
    },
    LoadError(LoadError),
    Unauthenticated {
@@ -74,6 +84,7 @@ impl AcpThreadView {
    pub fn new(
        workspace: WeakEntity<Workspace>,
        project: Entity<Project>,
+        message_history: Rc<RefCell<MessageHistory<acp::SendUserMessageParams>>>,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) -> Self {
@@ -118,6 +129,17 @@ impl AcpThreadView {
            editor
        });

+        let message_editor_subscription = cx.subscribe(&message_editor, |this, _, event, _| {
+            if let editor::EditorEvent::BufferEdited = &event {
+                if !this.message_set_from_history {
+                    this.message_history.borrow_mut().reset_position();
+                }
+                this.message_set_from_history = false;
+            }
+        });
+
+        let mention_set = mention_set.clone();
+
        let list_state = ListState::new(
            0,
            gpui::ListAlignment::Bottom,
@@ -136,10 +158,12 @@ impl AcpThreadView {
        );

        Self {
-            workspace,
+            workspace: workspace.clone(),
            project: project.clone(),
-            thread_state: Self::initial_state(project, window, cx),
+            thread_state: Self::initial_state(workspace, project, window, cx),
            message_editor,
+            message_set_from_history: false,
+            _message_editor_subscription: message_editor_subscription,
            mention_set,
            diff_editors: Default::default(),
            list_state: list_state,
@@ -147,11 +171,13 @@ impl AcpThreadView {
            auth_task: None,
            expanded_tool_calls: HashSet::default(),
            expanded_thinking_blocks: HashSet::default(),
-            message_history: MessageHistory::new(),
+            edits_expanded: false,
+            message_history,
        }
    }

    fn initial_state(
+        workspace: WeakEntity<Workspace>,
        project: Entity<Project>,
        window: &mut Window,
        cx: &mut Context<Self>,
@@ -219,15 +245,23 @@ impl AcpThreadView {
            this.update_in(cx, |this, window, cx| {
                match result {
                    Ok(()) => {
-                        let subscription =
+                        let thread_subscription =
                            cx.subscribe_in(&thread, window, Self::handle_thread_event);
+
+                        let action_log = thread.read(cx).action_log().clone();
+                        let action_log_subscription =
+                            cx.observe(&action_log, |_, _, cx| cx.notify());
+
                        this.list_state
                            .splice(0..0, thread.read(cx).entries().len());

+                        AgentDiff::set_active_thread(&workspace, thread.clone(), window, cx);
+
                        this.thread_state = ThreadState::Ready {
                            thread,
-                            _subscription: subscription,
+                            _subscription: [thread_subscription, action_log_subscription],
                        };
+
                        cx.notify();
                    }
                    Err(err) => {
@@ -250,7 +284,7 @@ impl AcpThreadView {
        cx.notify();
    }

-    fn thread(&self) -> Option<&Entity<AcpThread>> {
+    pub fn thread(&self) -> Option<&Entity<AcpThread>> {
        match &self.thread_state {
            ThreadState::Ready { thread, .. } | ThreadState::Unauthenticated { thread } => {
                Some(thread)
@@ -281,7 +315,6 @@ impl AcpThreadView {

        let mut ix = 0;
        let mut chunks: Vec<acp::UserMessageChunk> = Vec::new();
-
        let project = self.project.clone();
        self.message_editor.update(cx, |editor, cx| {
            let text = editor.text(cx);
@@ -342,7 +375,7 @@ impl AcpThreadView {
            editor.remove_creases(mention_set.lock().drain(), cx)
        });

-        self.message_history.push(message);
+        self.message_history.borrow_mut().push(message);
    }

    fn previous_history_message(
@@ -351,11 +384,11 @@ impl AcpThreadView {
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
-        Self::set_draft_message(
+        self.message_set_from_history = Self::set_draft_message(
            self.message_editor.clone(),
            self.mention_set.clone(),
            self.project.clone(),
-            self.message_history.prev(),
+            self.message_history.borrow_mut().prev(),
            window,
            cx,
        );
@@ -367,11 +400,11 @@ impl AcpThreadView {
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
-        Self::set_draft_message(
+        self.message_set_from_history = Self::set_draft_message(
            self.message_editor.clone(),
            self.mention_set.clone(),
            self.project.clone(),
-            self.message_history.next(),
+            self.message_history.borrow_mut().next(),
            window,
            cx,
        );
@@ -384,15 +417,11 @@ impl AcpThreadView {
        message: Option<&acp::SendUserMessageParams>,
        window: &mut Window,
        cx: &mut Context<Self>,
-    ) {
+    ) -> bool {
        cx.notify();

        let Some(message) = message else {
-            message_editor.update(cx, |editor, cx| {
-                editor.clear(window, cx);
-                editor.remove_creases(mention_set.lock().drain(), cx)
-            });
-            return;
+            return false;
        };

        let mut text = String::new();
@@ -452,6 +481,35 @@ impl AcpThreadView {
                mention_set.lock().insert(crease_id, project_path);
            }
        }
+
+        true
+    }
+
+    fn open_agent_diff(&mut self, _: &OpenAgentDiff, window: &mut Window, cx: &mut Context<Self>) {
+        if let Some(thread) = self.thread() {
+            AgentDiffPane::deploy(thread.clone(), self.workspace.clone(), window, cx).log_err();
+        }
+    }
+
+    fn open_edited_buffer(
+        &mut self,
+        buffer: &Entity<Buffer>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(thread) = self.thread() else {
+            return;
+        };
+
+        let Some(diff) =
+            AgentDiffPane::deploy(thread.clone(), self.workspace.clone(), window, cx).log_err()
+        else {
+            return;
+        };
+
+        diff.update(cx, |diff, cx| {
+            diff.move_to_path(PathKey::for_buffer(&buffer, cx), window, cx)
+        })
    }

    fn handle_thread_event(
@@ -464,7 +522,8 @@ impl AcpThreadView {
        let count = self.list_state.item_count();
        match event {
            AcpThreadEvent::NewEntry => {
-                self.sync_thread_entry_view(thread.read(cx).entries().len() - 1, window, cx);
+                let index = thread.read(cx).entries().len() - 1;
+                self.sync_thread_entry_view(index, window, cx);
                self.list_state.splice(count..count, 1);
            }
            AcpThreadEvent::EntryUpdated(index) => {
@@ -537,15 +596,7 @@ impl AcpThreadView {

    fn entry_diff_multibuffer(&self, entry_ix: usize, cx: &App) -> Option<Entity<MultiBuffer>> {
        let entry = self.thread()?.read(cx).entries().get(entry_ix)?;
-        if let AgentThreadEntry::ToolCall(ToolCall {
-            content: Some(ToolCallContent::Diff { diff }),
-            ..
-        }) = &entry
-        {
-            Some(diff.multibuffer.clone())
-        } else {
-            None
-        }
+        entry.diff().map(|diff| diff.multibuffer.clone())
    }

    fn authenticate(&mut self, window: &mut Window, cx: &mut Context<Self>) {
@@ -566,7 +617,8 @@ impl AcpThreadView {
                            Markdown::new(format!("Error: {err}").into(), None, None, cx)
                        }))
                    } else {
-                        this.thread_state = Self::initial_state(project.clone(), window, cx)
+                        this.thread_state =
+                            Self::initial_state(this.workspace.clone(), project.clone(), window, cx)
                    }
                    this.auth_task.take()
                })
@@ -1529,6 +1581,357 @@ impl AcpThreadView {
        container.into_any()
    }

+    fn render_edits_bar(
+        &self,
+        thread_entity: &Entity<AcpThread>,
+        window: &mut Window,
+        cx: &Context<Self>,
+    ) -> Option<AnyElement> {
+        let thread = thread_entity.read(cx);
+        let action_log = thread.action_log();
+        let changed_buffers = action_log.read(cx).changed_buffers(cx);
+
+        if changed_buffers.is_empty() {
+            return None;
+        }
+
+        let editor_bg_color = cx.theme().colors().editor_background;
+        let active_color = cx.theme().colors().element_selected;
+        let bg_edit_files_disclosure = editor_bg_color.blend(active_color.opacity(0.3));
+
+        let pending_edits = thread.has_pending_edit_tool_calls();
+        let expanded = self.edits_expanded;
+
+        v_flex()
+            .mt_1()
+            .mx_2()
+            .bg(bg_edit_files_disclosure)
+            .border_1()
+            .border_b_0()
+            .border_color(cx.theme().colors().border)
+            .rounded_t_md()
+            .shadow(vec![gpui::BoxShadow {
+                color: gpui::black().opacity(0.15),
+                offset: point(px(1.), px(-1.)),
+                blur_radius: px(3.),
+                spread_radius: px(0.),
+            }])
+            .child(self.render_edits_bar_summary(
+                action_log,
+                &changed_buffers,
+                expanded,
+                pending_edits,
+                window,
+                cx,
+            ))
+            .when(expanded, |parent| {
+                parent.child(self.render_edits_bar_files(
+                    action_log,
+                    &changed_buffers,
+                    pending_edits,
+                    cx,
+                ))
+            })
+            .into_any()
+            .into()
+    }
+
+    fn render_edits_bar_summary(
+        &self,
+        action_log: &Entity<ActionLog>,
+        changed_buffers: &BTreeMap<Entity<Buffer>, Entity<BufferDiff>>,
+        expanded: bool,
+        pending_edits: bool,
+        window: &mut Window,
+        cx: &Context<Self>,
+    ) -> Div {
+        const EDIT_NOT_READY_TOOLTIP_LABEL: &str = "Wait until file edits are complete.";
+
+        let focus_handle = self.focus_handle(cx);
+
+        h_flex()
+            .p_1()
+            .justify_between()
+            .when(expanded, |this| {
+                this.border_b_1().border_color(cx.theme().colors().border)
+            })
+            .child(
+                h_flex()
+                    .id("edits-container")
+                    .cursor_pointer()
+                    .w_full()
+                    .gap_1()
+                    .child(Disclosure::new("edits-disclosure", expanded))
+                    .map(|this| {
+                        if pending_edits {
+                            this.child(
+                                Label::new(format!(
+                                    "Editing {} {}…",
+                                    changed_buffers.len(),
+                                    if changed_buffers.len() == 1 {
+                                        "file"
+                                    } else {
+                                        "files"
+                                    }
+                                ))
+                                .color(Color::Muted)
+                                .size(LabelSize::Small)
+                                .with_animation(
+                                    "edit-label",
+                                    Animation::new(Duration::from_secs(2))
+                                        .repeat()
+                                        .with_easing(pulsating_between(0.3, 0.7)),
+                                    |label, delta| label.alpha(delta),
+                                ),
+                            )
+                        } else {
+                            this.child(
+                                Label::new("Edits")
+                                    .size(LabelSize::Small)
+                                    .color(Color::Muted),
+                            )
+                            .child(Label::new("•").size(LabelSize::XSmall).color(Color::Muted))
+                            .child(
+                                Label::new(format!(
+                                    "{} {}",
+                                    changed_buffers.len(),
+                                    if changed_buffers.len() == 1 {
+                                        "file"
+                                    } else {
+                                        "files"
+                                    }
+                                ))
+                                .size(LabelSize::Small)
+                                .color(Color::Muted),
+                            )
+                        }
+                    })
+                    .on_click(cx.listener(|this, _, _, cx| {
+                        this.edits_expanded = !this.edits_expanded;
+                        cx.notify();
+                    })),
+            )
+            .child(
+                h_flex()
+                    .gap_1()
+                    .child(
+                        IconButton::new("review-changes", IconName::ListTodo)
+                            .icon_size(IconSize::Small)
+                            .tooltip({
+                                let focus_handle = focus_handle.clone();
+                                move |window, cx| {
+                                    Tooltip::for_action_in(
+                                        "Review Changes",
+                                        &OpenAgentDiff,
+                                        &focus_handle,
+                                        window,
+                                        cx,
+                                    )
+                                }
+                            })
+                            .on_click(cx.listener(|_, _, window, cx| {
+                                window.dispatch_action(OpenAgentDiff.boxed_clone(), cx);
+                            })),
+                    )
+                    .child(Divider::vertical().color(DividerColor::Border))
+                    .child(
+                        Button::new("reject-all-changes", "Reject All")
+                            .label_size(LabelSize::Small)
+                            .disabled(pending_edits)
+                            .when(pending_edits, |this| {
+                                this.tooltip(Tooltip::text(EDIT_NOT_READY_TOOLTIP_LABEL))
+                            })
+                            .key_binding(
+                                KeyBinding::for_action_in(
+                                    &RejectAll,
+                                    &focus_handle.clone(),
+                                    window,
+                                    cx,
+                                )
+                                .map(|kb| kb.size(rems_from_px(10.))),
+                            )
+                            .on_click({
+                                let action_log = action_log.clone();
+                                cx.listener(move |_, _, _, cx| {
+                                    action_log.update(cx, |action_log, cx| {
+                                        action_log.reject_all_edits(cx).detach();
+                                    })
+                                })
+                            }),
+                    )
+                    .child(
+                        Button::new("keep-all-changes", "Keep All")
+                            .label_size(LabelSize::Small)
+                            .disabled(pending_edits)
+                            .when(pending_edits, |this| {
+                                this.tooltip(Tooltip::text(EDIT_NOT_READY_TOOLTIP_LABEL))
+                            })
+                            .key_binding(
+                                KeyBinding::for_action_in(&KeepAll, &focus_handle, window, cx)
+                                    .map(|kb| kb.size(rems_from_px(10.))),
+                            )
+                            .on_click({
+                                let action_log = action_log.clone();
+                                cx.listener(move |_, _, _, cx| {
+                                    action_log.update(cx, |action_log, cx| {
+                                        action_log.keep_all_edits(cx);
+                                    })
+                                })
+                            }),
+                    ),
+            )
+    }
+
+    fn render_edits_bar_files(
+        &self,
+        action_log: &Entity<ActionLog>,
+        changed_buffers: &BTreeMap<Entity<Buffer>, Entity<BufferDiff>>,
+        pending_edits: bool,
+        cx: &Context<Self>,
+    ) -> Div {
+        let editor_bg_color = cx.theme().colors().editor_background;
+
+        v_flex().children(changed_buffers.into_iter().enumerate().flat_map(
+            |(index, (buffer, _diff))| {
+                let file = buffer.read(cx).file()?;
+                let path = file.path();
+
+                let file_path = path.parent().and_then(|parent| {
+                    let parent_str = parent.to_string_lossy();
+
+                    if parent_str.is_empty() {
+                        None
+                    } else {
+                        Some(
+                            Label::new(format!("/{}{}", parent_str, std::path::MAIN_SEPARATOR_STR))
+                                .color(Color::Muted)
+                                .size(LabelSize::XSmall)
+                                .buffer_font(cx),
+                        )
+                    }
+                });
+
+                let file_name = path.file_name().map(|name| {
+                    Label::new(name.to_string_lossy().to_string())
+                        .size(LabelSize::XSmall)
+                        .buffer_font(cx)
+                });
+
+                let file_icon = FileIcons::get_icon(&path, cx)
+                    .map(Icon::from_path)
+                    .map(|icon| icon.color(Color::Muted).size(IconSize::Small))
+                    .unwrap_or_else(|| {
+                        Icon::new(IconName::File)
+                            .color(Color::Muted)
+                            .size(IconSize::Small)
+                    });
+
+                let overlay_gradient = linear_gradient(
+                    90.,
+                    linear_color_stop(editor_bg_color, 1.),
+                    linear_color_stop(editor_bg_color.opacity(0.2), 0.),
+                );
+
+                let element = h_flex()
+                    .group("edited-code")
+                    .id(("file-container", index))
+                    .relative()
+                    .py_1()
+                    .pl_2()
+                    .pr_1()
+                    .gap_2()
+                    .justify_between()
+                    .bg(editor_bg_color)
+                    .when(index < changed_buffers.len() - 1, |parent| {
+                        parent.border_color(cx.theme().colors().border).border_b_1()
+                    })
+                    .child(
+                        h_flex()
+                            .id(("file-name", index))
+                            .pr_8()
+                            .gap_1p5()
+                            .max_w_full()
+                            .overflow_x_scroll()
+                            .child(file_icon)
+                            .child(h_flex().gap_0p5().children(file_name).children(file_path))
+                            .on_click({
+                                let buffer = buffer.clone();
+                                cx.listener(move |this, _, window, cx| {
+                                    this.open_edited_buffer(&buffer, window, cx);
+                                })
+                            }),
+                    )
+                    .child(
+                        h_flex()
+                            .gap_1()
+                            .visible_on_hover("edited-code")
+                            .child(
+                                Button::new("review", "Review")
+                                    .label_size(LabelSize::Small)
+                                    .on_click({
+                                        let buffer = buffer.clone();
+                                        cx.listener(move |this, _, window, cx| {
+                                            this.open_edited_buffer(&buffer, window, cx);
+                                        })
+                                    }),
+                            )
+                            .child(Divider::vertical().color(DividerColor::BorderVariant))
+                            .child(
+                                Button::new("reject-file", "Reject")
+                                    .label_size(LabelSize::Small)
+                                    .disabled(pending_edits)
+                                    .on_click({
+                                        let buffer = buffer.clone();
+                                        let action_log = action_log.clone();
+                                        move |_, _, cx| {
+                                            action_log.update(cx, |action_log, cx| {
+                                                action_log
+                                                    .reject_edits_in_ranges(
+                                                        buffer.clone(),
+                                                        vec![Anchor::MIN..Anchor::MAX],
+                                                        cx,
+                                                    )
+                                                    .detach_and_log_err(cx);
+                                            })
+                                        }
+                                    }),
+                            )
+                            .child(
+                                Button::new("keep-file", "Keep")
+                                    .label_size(LabelSize::Small)
+                                    .disabled(pending_edits)
+                                    .on_click({
+                                        let buffer = buffer.clone();
+                                        let action_log = action_log.clone();
+                                        move |_, _, cx| {
+                                            action_log.update(cx, |action_log, cx| {
+                                                action_log.keep_edits_in_range(
+                                                    buffer.clone(),
+                                                    Anchor::MIN..Anchor::MAX,
+                                                    cx,
+                                                );
+                                            })
+                                        }
+                                    }),
+                            ),
+                    )
+                    .child(
+                        div()
+                            .id("gradient-overlay")
+                            .absolute()
+                            .h_full()
+                            .w_12()
+                            .top_0()
+                            .bottom_0()
+                            .right(px(152.))
+                            .bg(overlay_gradient),
+                    );
+
+                Some(element)
+            },
+        ))
+    }
+
    fn render_message_editor(&mut self, cx: &mut Context<Self>) -> AnyElement {
        let settings = ThemeSettings::get_global(cx);
        let font_size = TextSize::Small
@@ -1559,6 +1962,76 @@ impl AcpThreadView {
        .into_any()
    }

+    fn render_send_button(&self, cx: &mut Context<Self>) -> AnyElement {
+        if self.thread().map_or(true, |thread| {
+            thread.read(cx).status() == ThreadStatus::Idle
+        }) {
+            let is_editor_empty = self.message_editor.read(cx).is_empty(cx);
+            IconButton::new("send-message", IconName::Send)
+                .icon_color(Color::Accent)
+                .style(ButtonStyle::Filled)
+                .disabled(self.thread().is_none() || is_editor_empty)
+                .on_click(cx.listener(|this, _, window, cx| {
+                    this.chat(&Chat, window, cx);
+                }))
+                .when(!is_editor_empty, |button| {
+                    button.tooltip(move |window, cx| Tooltip::for_action("Send", &Chat, window, cx))
+                })
+                .when(is_editor_empty, |button| {
+                    button.tooltip(Tooltip::text("Type a message to submit"))
+                })
+                .into_any_element()
+        } else {
+            IconButton::new("stop-generation", IconName::StopFilled)
+                .icon_color(Color::Error)
+                .style(ButtonStyle::Tinted(ui::TintColor::Error))
+                .tooltip(move |window, cx| {
+                    Tooltip::for_action("Stop Generation", &editor::actions::Cancel, window, cx)
+                })
+                .on_click(cx.listener(|this, _event, _, cx| this.cancel(cx)))
+                .into_any_element()
+        }
+    }
+
+    fn render_follow_toggle(&self, cx: &mut Context<Self>) -> impl IntoElement {
+        let following = self
+            .workspace
+            .read_with(cx, |workspace, _| {
+                workspace.is_being_followed(CollaboratorId::Agent)
+            })
+            .unwrap_or(false);
+
+        IconButton::new("follow-agent", IconName::Crosshair)
+            .icon_size(IconSize::Small)
+            .icon_color(Color::Muted)
+            .toggle_state(following)
+            .selected_icon_color(Some(Color::Custom(cx.theme().players().agent().cursor)))
+            .tooltip(move |window, cx| {
+                if following {
+                    Tooltip::for_action("Stop Following Agent", &Follow, window, cx)
+                } else {
+                    Tooltip::with_meta(
+                        "Follow Agent",
+                        Some(&Follow),
+                        "Track the agent's location as it reads and edits files.",
+                        window,
+                        cx,
+                    )
+                }
+            })
+            .on_click(cx.listener(move |this, _, window, cx| {
+                this.workspace
+                    .update(cx, |workspace, cx| {
+                        if following {
+                            workspace.unfollow(CollaboratorId::Agent, window, cx);
+                        } else {
+                            workspace.follow(CollaboratorId::Agent, window, cx);
+                        }
+                    })
+                    .ok();
+            }))
+    }
+
    fn render_markdown(&self, markdown: Entity<Markdown>, style: MarkdownStyle) -> MarkdownElement {
        let workspace = self.workspace.clone();
        MarkdownElement::new(markdown, style).on_url_click(move |text, window, cx| {
@@ -1673,10 +2146,6 @@ impl Focusable for AcpThreadView {

 impl Render for AcpThreadView {
    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let text = self.message_editor.read(cx).text(cx);
-        let is_editor_empty = text.is_empty();
-        let focus_handle = self.message_editor.focus_handle(cx);
-
        let open_as_markdown = IconButton::new("open-as-markdown", IconName::DocumentText)
            .icon_size(IconSize::XSmall)
            .icon_color(Color::Ignored)
@@ -1702,6 +2171,7 @@ impl Render for AcpThreadView {
            .on_action(cx.listener(Self::chat))
            .on_action(cx.listener(Self::previous_history_message))
            .on_action(cx.listener(Self::next_history_message))
+            .on_action(cx.listener(Self::open_agent_diff))
            .child(match &self.thread_state {
                ThreadState::Unauthenticated { .. } => v_flex()
                    .p_2()
@@ -1755,6 +2225,7 @@ impl Render for AcpThreadView {
                                .child(LoadingLabel::new("").size(LabelSize::Small))
                                .into(),
                        })
+                        .children(self.render_edits_bar(&thread, window, cx))
                    } else {
                        this.child(self.render_empty_state(false, cx))
                    }
@@ -1782,47 +2253,12 @@ impl Render for AcpThreadView {
                    .border_t_1()
                    .border_color(cx.theme().colors().border)
                    .child(self.render_message_editor(cx))
-                    .child({
-                        let thread = self.thread();
-
-                        h_flex().justify_end().child(
-                            if thread.map_or(true, |thread| {
-                                thread.read(cx).status() == ThreadStatus::Idle
-                            }) {
-                                IconButton::new("send-message", IconName::Send)
-                                    .icon_color(Color::Accent)
-                                    .style(ButtonStyle::Filled)
-                                    .disabled(thread.is_none() || is_editor_empty)
-                                    .on_click({
-                                        let focus_handle = focus_handle.clone();
-                                        move |_event, window, cx| {
-                                            focus_handle.dispatch_action(&Chat, window, cx);
-                                        }
-                                    })
-                                    .when(!is_editor_empty, |button| {
-                                        button.tooltip(move |window, cx| {
-                                            Tooltip::for_action("Send", &Chat, window, cx)
-                                        })
-                                    })
-                                    .when(is_editor_empty, |button| {
-                                        button.tooltip(Tooltip::text("Type a message to submit"))
-                                    })
-                            } else {
-                                IconButton::new("stop-generation", IconName::StopFilled)
-                                    .icon_color(Color::Error)
-                                    .style(ButtonStyle::Tinted(ui::TintColor::Error))
-                                    .tooltip(move |window, cx| {
-                                        Tooltip::for_action(
-                                            "Stop Generation",
-                                            &editor::actions::Cancel,
-                                            window,
-                                            cx,
-                                        )
-                                    })
-                                    .on_click(cx.listener(|this, _event, _, cx| this.cancel(cx)))
-                            },
-                        )
-                    }),
+                    .child(
+                        h_flex()
+                            .justify_between()
+                            .child(self.render_follow_toggle(cx))
+                            .child(self.render_send_button(cx)),
+                    ),
            )
    }
 }
--- a/crates/agent_ui/src/agent_diff.rs
+++ b/crates/agent_ui/src/agent_diff.rs
@@ -1,7 +1,9 @@
 use crate::{Keep, KeepAll, OpenAgentDiff, Reject, RejectAll};
-use agent::{Thread, ThreadEvent};
+use acp::{AcpThread, AcpThreadEvent};
+use agent::{Thread, ThreadEvent, ThreadSummary};
 use agent_settings::AgentSettings;
 use anyhow::Result;
+use assistant_tool::ActionLog;
 use buffer_diff::DiffHunkStatus;
 use collections::{HashMap, HashSet};
 use editor::{
@@ -41,16 +43,108 @@ use zed_actions::assistant::ToggleFocus;
 pub struct AgentDiffPane {
    multibuffer: Entity<MultiBuffer>,
    editor: Entity<Editor>,
-    thread: Entity<Thread>,
+    thread: AgentDiffThread,
    focus_handle: FocusHandle,
    workspace: WeakEntity<Workspace>,
    title: SharedString,
    _subscriptions: Vec<Subscription>,
 }

+#[derive(PartialEq, Eq, Clone)]
+pub enum AgentDiffThread {
+    Native(Entity<Thread>),
+    AcpThread(Entity<AcpThread>),
+}
+
+impl AgentDiffThread {
+    fn project(&self, cx: &App) -> Entity<Project> {
+        match self {
+            AgentDiffThread::Native(thread) => thread.read(cx).project().clone(),
+            AgentDiffThread::AcpThread(thread) => thread.read(cx).project().clone(),
+        }
+    }
+    fn action_log(&self, cx: &App) -> Entity<ActionLog> {
+        match self {
+            AgentDiffThread::Native(thread) => thread.read(cx).action_log().clone(),
+            AgentDiffThread::AcpThread(thread) => thread.read(cx).action_log().clone(),
+        }
+    }
+
+    fn summary(&self, cx: &App) -> ThreadSummary {
+        match self {
+            AgentDiffThread::Native(thread) => thread.read(cx).summary().clone(),
+            AgentDiffThread::AcpThread(thread) => ThreadSummary::Ready(thread.read(cx).title()),
+        }
+    }
+
+    fn is_generating(&self, cx: &App) -> bool {
+        match self {
+            AgentDiffThread::Native(thread) => thread.read(cx).is_generating(),
+            AgentDiffThread::AcpThread(thread) => {
+                thread.read(cx).status() == acp::ThreadStatus::Generating
+            }
+        }
+    }
+
+    fn has_pending_edit_tool_uses(&self, cx: &App) -> bool {
+        match self {
+            AgentDiffThread::Native(thread) => thread.read(cx).has_pending_edit_tool_uses(),
+            AgentDiffThread::AcpThread(thread) => thread.read(cx).has_pending_edit_tool_calls(),
+        }
+    }
+
+    fn downgrade(&self) -> WeakAgentDiffThread {
+        match self {
+            AgentDiffThread::Native(thread) => WeakAgentDiffThread::Native(thread.downgrade()),
+            AgentDiffThread::AcpThread(thread) => {
+                WeakAgentDiffThread::AcpThread(thread.downgrade())
+            }
+        }
+    }
+}
+
+impl From<Entity<Thread>> for AgentDiffThread {
+    fn from(entity: Entity<Thread>) -> Self {
+        AgentDiffThread::Native(entity)
+    }
+}
+
+impl From<Entity<AcpThread>> for AgentDiffThread {
+    fn from(entity: Entity<AcpThread>) -> Self {
+        AgentDiffThread::AcpThread(entity)
+    }
+}
+
+#[derive(PartialEq, Eq, Clone)]
+pub enum WeakAgentDiffThread {
+    Native(WeakEntity<Thread>),
+    AcpThread(WeakEntity<AcpThread>),
+}
+
+impl WeakAgentDiffThread {
+    pub fn upgrade(&self) -> Option<AgentDiffThread> {
+        match self {
+            WeakAgentDiffThread::Native(weak) => weak.upgrade().map(AgentDiffThread::Native),
+            WeakAgentDiffThread::AcpThread(weak) => weak.upgrade().map(AgentDiffThread::AcpThread),
+        }
+    }
+}
+
+impl From<WeakEntity<Thread>> for WeakAgentDiffThread {
+    fn from(entity: WeakEntity<Thread>) -> Self {
+        WeakAgentDiffThread::Native(entity)
+    }
+}
+
+impl From<WeakEntity<AcpThread>> for WeakAgentDiffThread {
+    fn from(entity: WeakEntity<AcpThread>) -> Self {
+        WeakAgentDiffThread::AcpThread(entity)
+    }
+}
+
 impl AgentDiffPane {
    pub fn deploy(
-        thread: Entity<Thread>,
+        thread: impl Into<AgentDiffThread>,
        workspace: WeakEntity<Workspace>,
        window: &mut Window,
        cx: &mut App,
@@ -61,14 +155,16 @@ impl AgentDiffPane {
    }

    pub fn deploy_in_workspace(
-        thread: Entity<Thread>,
+        thread: impl Into<AgentDiffThread>,
        workspace: &mut Workspace,
        window: &mut Window,
        cx: &mut Context<Workspace>,
    ) -> Entity<Self> {
+        let thread = thread.into();
        let existing_diff = workspace
            .items_of_type::<AgentDiffPane>(cx)
            .find(|diff| diff.read(cx).thread == thread);
+
        if let Some(existing_diff) = existing_diff {
            workspace.activate_item(&existing_diff, true, true, window, cx);
            existing_diff
@@ -81,7 +177,7 @@ impl AgentDiffPane {
    }

    pub fn new(
-        thread: Entity<Thread>,
+        thread: AgentDiffThread,
        workspace: WeakEntity<Workspace>,
        window: &mut Window,
        cx: &mut Context<Self>,
@@ -89,7 +185,7 @@ impl AgentDiffPane {
        let focus_handle = cx.focus_handle();
        let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));

-        let project = thread.read(cx).project().clone();
+        let project = thread.project(cx).clone();
        let editor = cx.new(|cx| {
            let mut editor =
                Editor::for_multibuffer(multibuffer.clone(), Some(project.clone()), window, cx);
@@ -100,16 +196,27 @@ impl AgentDiffPane {
            editor
        });

-        let action_log = thread.read(cx).action_log().clone();
+        let action_log = thread.action_log(cx).clone();
+
        let mut this = Self {
-            _subscriptions: vec![
-                cx.observe_in(&action_log, window, |this, _action_log, window, cx| {
-                    this.update_excerpts(window, cx)
-                }),
-                cx.subscribe(&thread, |this, _thread, event, cx| {
-                    this.handle_thread_event(event, cx)
-                }),
-            ],
+            _subscriptions: [
+                Some(
+                    cx.observe_in(&action_log, window, |this, _action_log, window, cx| {
+                        this.update_excerpts(window, cx)
+                    }),
+                ),
+                match &thread {
+                    AgentDiffThread::Native(thread) => {
+                        Some(cx.subscribe(&thread, |this, _thread, event, cx| {
+                            this.handle_thread_event(event, cx)
+                        }))
+                    }
+                    AgentDiffThread::AcpThread(_) => None,
+                },
+            ]
+            .into_iter()
+            .flatten()
+            .collect(),
            title: SharedString::default(),
            multibuffer,
            editor,
@@ -123,8 +230,7 @@ impl AgentDiffPane {
    }

    fn update_excerpts(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        let thread = self.thread.read(cx);
-        let changed_buffers = thread.action_log().read(cx).changed_buffers(cx);
+        let changed_buffers = self.thread.action_log(cx).read(cx).changed_buffers(cx);
        let mut paths_to_delete = self.multibuffer.read(cx).paths().collect::<HashSet<_>>();

        for (buffer, diff_handle) in changed_buffers {
@@ -211,7 +317,7 @@ impl AgentDiffPane {
    }

    fn update_title(&mut self, cx: &mut Context<Self>) {
-        let new_title = self.thread.read(cx).summary().unwrap_or("Agent Changes");
+        let new_title = self.thread.summary(cx).unwrap_or("Agent Changes");
        if new_title != self.title {
            self.title = new_title;
            cx.emit(EditorEvent::TitleChanged);
@@ -275,14 +381,15 @@ impl AgentDiffPane {

    fn keep_all(&mut self, _: &KeepAll, _window: &mut Window, cx: &mut Context<Self>) {
        self.thread
-            .update(cx, |thread, cx| thread.keep_all_edits(cx));
+            .action_log(cx)
+            .update(cx, |action_log, cx| action_log.keep_all_edits(cx))
    }
 }

 fn keep_edits_in_selection(
    editor: &mut Editor,
    buffer_snapshot: &MultiBufferSnapshot,
-    thread: &Entity<Thread>,
+    thread: &AgentDiffThread,
    window: &mut Window,
    cx: &mut Context<Editor>,
 ) {
@@ -297,7 +404,7 @@ fn keep_edits_in_selection(
 fn reject_edits_in_selection(
    editor: &mut Editor,
    buffer_snapshot: &MultiBufferSnapshot,
-    thread: &Entity<Thread>,
+    thread: &AgentDiffThread,
    window: &mut Window,
    cx: &mut Context<Editor>,
 ) {
@@ -311,7 +418,7 @@ fn reject_edits_in_selection(
 fn keep_edits_in_ranges(
    editor: &mut Editor,
    buffer_snapshot: &MultiBufferSnapshot,
-    thread: &Entity<Thread>,
+    thread: &AgentDiffThread,
    ranges: Vec<Range<editor::Anchor>>,
    window: &mut Window,
    cx: &mut Context<Editor>,
@@ -326,8 +433,8 @@ fn keep_edits_in_ranges(
    for hunk in &diff_hunks_in_ranges {
        let buffer = multibuffer.read(cx).buffer(hunk.buffer_id);
        if let Some(buffer) = buffer {
-            thread.update(cx, |thread, cx| {
-                thread.keep_edits_in_range(buffer, hunk.buffer_range.clone(), cx)
+            thread.action_log(cx).update(cx, |action_log, cx| {
+                action_log.keep_edits_in_range(buffer, hunk.buffer_range.clone(), cx)
            });
        }
    }
@@ -336,7 +443,7 @@ fn keep_edits_in_ranges(
 fn reject_edits_in_ranges(
    editor: &mut Editor,
    buffer_snapshot: &MultiBufferSnapshot,
-    thread: &Entity<Thread>,
+    thread: &AgentDiffThread,
    ranges: Vec<Range<editor::Anchor>>,
    window: &mut Window,
    cx: &mut Context<Editor>,
@@ -362,8 +469,9 @@ fn reject_edits_in_ranges(

    for (buffer, ranges) in ranges_by_buffer {
        thread
-            .update(cx, |thread, cx| {
-                thread.reject_edits_in_ranges(buffer, ranges, cx)
+            .action_log(cx)
+            .update(cx, |action_log, cx| {
+                action_log.reject_edits_in_ranges(buffer, ranges, cx)
            })
            .detach_and_log_err(cx);
    }
@@ -461,7 +569,7 @@ impl Item for AgentDiffPane {
    }

    fn tab_content(&self, params: TabContentParams, _window: &Window, cx: &App) -> AnyElement {
-        let summary = self.thread.read(cx).summary().unwrap_or("Agent Changes");
+        let summary = self.thread.summary(cx).unwrap_or("Agent Changes");
        Label::new(format!("Review: {}", summary))
            .color(if params.selected {
                Color::Default
@@ -641,7 +749,7 @@ impl Render for AgentDiffPane {
    }
 }

-fn diff_hunk_controls(thread: &Entity<Thread>) -> editor::RenderDiffHunkControlsFn {
+fn diff_hunk_controls(thread: &AgentDiffThread) -> editor::RenderDiffHunkControlsFn {
    let thread = thread.clone();

    Arc::new(
@@ -676,7 +784,7 @@ fn render_diff_hunk_controls(
    hunk_range: Range<editor::Anchor>,
    is_created_file: bool,
    line_height: Pixels,
-    thread: &Entity<Thread>,
+    thread: &AgentDiffThread,
    editor: &Entity<Editor>,
    window: &mut Window,
    cx: &mut App,
@@ -1112,11 +1220,8 @@ impl Render for AgentDiffToolbar {
                    return Empty.into_any();
                };

-                let has_pending_edit_tool_use = agent_diff
-                    .read(cx)
-                    .thread
-                    .read(cx)
-                    .has_pending_edit_tool_uses();
+                let has_pending_edit_tool_use =
+                    agent_diff.read(cx).thread.has_pending_edit_tool_uses(cx);

                if has_pending_edit_tool_use {
                    return div().px_2().child(spinner_icon).into_any();
@@ -1187,8 +1292,8 @@ pub enum EditorState {
 }

 struct WorkspaceThread {
-    thread: WeakEntity<Thread>,
-    _thread_subscriptions: [Subscription; 2],
+    thread: WeakAgentDiffThread,
+    _thread_subscriptions: (Subscription, Subscription),
    singleton_editors: HashMap<WeakEntity<Buffer>, HashMap<WeakEntity<Editor>, Subscription>>,
    _settings_subscription: Subscription,
    _workspace_subscription: Option<Subscription>,
@@ -1212,23 +1317,23 @@ impl AgentDiff {

    pub fn set_active_thread(
        workspace: &WeakEntity<Workspace>,
-        thread: &Entity<Thread>,
+        thread: impl Into<AgentDiffThread>,
        window: &mut Window,
        cx: &mut App,
    ) {
        Self::global(cx).update(cx, |this, cx| {
-            this.register_active_thread_impl(workspace, thread, window, cx);
+            this.register_active_thread_impl(workspace, thread.into(), window, cx);
        });
    }

    fn register_active_thread_impl(
        &mut self,
        workspace: &WeakEntity<Workspace>,
-        thread: &Entity<Thread>,
+        thread: AgentDiffThread,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
-        let action_log = thread.read(cx).action_log().clone();
+        let action_log = thread.action_log(cx).clone();

        let action_log_subscription = cx.observe_in(&action_log, window, {
            let workspace = workspace.clone();
@@ -1237,17 +1342,25 @@ impl AgentDiff {
            }
        });

-        let thread_subscription = cx.subscribe_in(&thread, window, {
-            let workspace = workspace.clone();
-            move |this, _thread, event, window, cx| {
-                this.handle_thread_event(&workspace, event, window, cx)
-            }
-        });
+        let thread_subscription = match &thread {
+            AgentDiffThread::Native(thread) => cx.subscribe_in(&thread, window, {
+                let workspace = workspace.clone();
+                move |this, _thread, event, window, cx| {
+                    this.handle_native_thread_event(&workspace, event, window, cx)
+                }
+            }),
+            AgentDiffThread::AcpThread(thread) => cx.subscribe_in(&thread, window, {
+                let workspace = workspace.clone();
+                move |this, thread, event, window, cx| {
+                    this.handle_acp_thread_event(&workspace, thread, event, window, cx)
+                }
+            }),
+        };

        if let Some(workspace_thread) = self.workspace_threads.get_mut(&workspace) {
            // replace thread and action log subscription, but keep editors
            workspace_thread.thread = thread.downgrade();
-            workspace_thread._thread_subscriptions = [action_log_subscription, thread_subscription];
+            workspace_thread._thread_subscriptions = (action_log_subscription, thread_subscription);
            self.update_reviewing_editors(&workspace, window, cx);
            return;
        }
@@ -1272,7 +1385,7 @@ impl AgentDiff {
            workspace.clone(),
            WorkspaceThread {
                thread: thread.downgrade(),
-                _thread_subscriptions: [action_log_subscription, thread_subscription],
+                _thread_subscriptions: (action_log_subscription, thread_subscription),
                singleton_editors: HashMap::default(),
                _settings_subscription: settings_subscription,
                _workspace_subscription: workspace_subscription,
@@ -1319,7 +1432,7 @@ impl AgentDiff {

    fn register_review_action<T: Action>(
        workspace: &mut Workspace,
-        review: impl Fn(&Entity<Editor>, &Entity<Thread>, &mut Window, &mut App) -> PostReviewState
+        review: impl Fn(&Entity<Editor>, &AgentDiffThread, &mut Window, &mut App) -> PostReviewState
        + 'static,
        this: &Entity<AgentDiff>,
    ) {
@@ -1338,7 +1451,7 @@ impl AgentDiff {
        });
    }

-    fn handle_thread_event(
+    fn handle_native_thread_event(
        &mut self,
        workspace: &WeakEntity<Workspace>,
        event: &ThreadEvent,
@@ -1380,6 +1493,40 @@ impl AgentDiff {
        }
    }

+    fn handle_acp_thread_event(
+        &mut self,
+        workspace: &WeakEntity<Workspace>,
+        thread: &Entity<AcpThread>,
+        event: &AcpThreadEvent,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        match event {
+            AcpThreadEvent::NewEntry => {
+                if thread
+                    .read(cx)
+                    .entries()
+                    .last()
+                    .and_then(|entry| entry.diff())
+                    .is_some()
+                {
+                    self.update_reviewing_editors(workspace, window, cx);
+                }
+            }
+            AcpThreadEvent::EntryUpdated(ix) => {
+                if thread
+                    .read(cx)
+                    .entries()
+                    .get(*ix)
+                    .and_then(|entry| entry.diff())
+                    .is_some()
+                {
+                    self.update_reviewing_editors(workspace, window, cx);
+                }
+            }
+        }
+    }
+
    fn handle_workspace_event(
        &mut self,
        workspace: &Entity<Workspace>,
@@ -1485,7 +1632,7 @@ impl AgentDiff {
            return;
        };

-        let action_log = thread.read(cx).action_log();
+        let action_log = thread.action_log(cx);
        let changed_buffers = action_log.read(cx).changed_buffers(cx);

        let mut unaffected = self.reviewing_editors.clone();
@@ -1510,7 +1657,7 @@ impl AgentDiff {
                    multibuffer.add_diff(diff_handle.clone(), cx);
                });

-                let new_state = if thread.read(cx).is_generating() {
+                let new_state = if thread.is_generating(cx) {
                    EditorState::Generating
                } else {
                    EditorState::Reviewing
@@ -1606,7 +1753,7 @@ impl AgentDiff {

    fn keep_all(
        editor: &Entity<Editor>,
-        thread: &Entity<Thread>,
+        thread: &AgentDiffThread,
        window: &mut Window,
        cx: &mut App,
    ) -> PostReviewState {
@@ -1626,7 +1773,7 @@ impl AgentDiff {

    fn reject_all(
        editor: &Entity<Editor>,
-        thread: &Entity<Thread>,
+        thread: &AgentDiffThread,
        window: &mut Window,
        cx: &mut App,
    ) -> PostReviewState {
@@ -1646,7 +1793,7 @@ impl AgentDiff {

    fn keep(
        editor: &Entity<Editor>,
-        thread: &Entity<Thread>,
+        thread: &AgentDiffThread,
        window: &mut Window,
        cx: &mut App,
    ) -> PostReviewState {
@@ -1659,7 +1806,7 @@ impl AgentDiff {

    fn reject(
        editor: &Entity<Editor>,
-        thread: &Entity<Thread>,
+        thread: &AgentDiffThread,
        window: &mut Window,
        cx: &mut App,
    ) -> PostReviewState {
@@ -1682,7 +1829,7 @@ impl AgentDiff {
    fn review_in_active_editor(
        &mut self,
        workspace: &mut Workspace,
-        review: impl Fn(&Entity<Editor>, &Entity<Thread>, &mut Window, &mut App) -> PostReviewState,
+        review: impl Fn(&Entity<Editor>, &AgentDiffThread, &mut Window, &mut App) -> PostReviewState,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) -> Option<Task<Result<()>>> {
@@ -1703,7 +1850,7 @@ impl AgentDiff {

        if let PostReviewState::AllReviewed = review(&editor, &thread, window, cx) {
            if let Some(curr_buffer) = editor.read(cx).buffer().read(cx).as_singleton() {
-                let changed_buffers = thread.read(cx).action_log().read(cx).changed_buffers(cx);
+                let changed_buffers = thread.action_log(cx).read(cx).changed_buffers(cx);

                let mut keys = changed_buffers.keys().cycle();
                keys.find(|k| *k == &curr_buffer);
@@ -1801,8 +1948,9 @@ mod tests {
            })
            .await
            .unwrap();
-        let thread = thread_store.update(cx, |store, cx| store.create_thread(cx));
-        let action_log = thread.read_with(cx, |thread, _| thread.action_log().clone());
+        let thread =
+            AgentDiffThread::Native(thread_store.update(cx, |store, cx| store.create_thread(cx)));
+        let action_log = cx.read(|cx| thread.action_log(cx));

        let (workspace, cx) =
            cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
@@ -1988,8 +2136,9 @@ mod tests {
        });

        // Set the active thread
+        let thread = AgentDiffThread::Native(thread);
        cx.update(|window, cx| {
-            AgentDiff::set_active_thread(&workspace.downgrade(), &thread, window, cx)
+            AgentDiff::set_active_thread(&workspace.downgrade(), thread.clone(), window, cx)
        });

        let buffer1 = project
--- a/crates/agent_ui/src/agent_panel.rs
+++ b/crates/agent_ui/src/agent_panel.rs
@@ -1,3 +1,4 @@
+use std::cell::RefCell;
 use std::ops::Range;
 use std::path::Path;
 use std::rc::Rc;
@@ -8,6 +9,7 @@ use db::kvp::{Dismissable, KEY_VALUE_STORE};
 use serde::{Deserialize, Serialize};

 use crate::NewAcpThread;
+use crate::agent_diff::AgentDiffThread;
 use crate::language_model_selector::ToggleModelSelector;
 use crate::{
    AddContextServer, AgentDiffPane, ContinueThread, ContinueWithBurnMode,
@@ -432,6 +434,8 @@ pub struct AgentPanel {
    configuration_subscription: Option<Subscription>,
    local_timezone: UtcOffset,
    active_view: ActiveView,
+    acp_message_history:
+        Rc<RefCell<crate::acp::MessageHistory<agentic_coding_protocol::SendUserMessageParams>>>,
    previous_view: Option<ActiveView>,
    history_store: Entity<HistoryStore>,
    history: Entity<ThreadHistory>,
@@ -624,7 +628,7 @@ impl AgentPanel {
            }
        };

-        AgentDiff::set_active_thread(&workspace, &thread, window, cx);
+        AgentDiff::set_active_thread(&workspace, thread.clone(), window, cx);

        let weak_panel = weak_self.clone();

@@ -698,6 +702,7 @@ impl AgentPanel {
            .unwrap(),
            inline_assist_context_store,
            previous_view: None,
+            acp_message_history: Default::default(),
            history_store: history_store.clone(),
            history: cx.new(|cx| ThreadHistory::new(weak_self, history_store, window, cx)),
            hovered_recent_history_item: None,
@@ -845,7 +850,7 @@ impl AgentPanel {
        let thread_view = ActiveView::thread(active_thread.clone(), message_editor, window, cx);
        self.set_active_view(thread_view, window, cx);

-        AgentDiff::set_active_thread(&self.workspace, &thread, window, cx);
+        AgentDiff::set_active_thread(&self.workspace, thread.clone(), window, cx);
    }

    fn new_prompt_editor(&mut self, window: &mut Window, cx: &mut Context<Self>) {
@@ -887,14 +892,30 @@ impl AgentPanel {
    fn new_gemini_thread(&mut self, window: &mut Window, cx: &mut Context<Self>) {
        let workspace = self.workspace.clone();
        let project = self.project.clone();
+        let message_history = self.acp_message_history.clone();

        cx.spawn_in(window, async move |this, cx| {
            let thread_view = cx.new_window_entity(|window, cx| {
-                crate::acp::AcpThreadView::new(workspace, project, window, cx)
+                crate::acp::AcpThreadView::new(
+                    workspace.clone(),
+                    project,
+                    message_history,
+                    window,
+                    cx,
+                )
            })?;
            this.update_in(cx, |this, window, cx| {
-                this.set_active_view(ActiveView::AcpThread { thread_view }, window, cx);
+                this.set_active_view(
+                    ActiveView::AcpThread {
+                        thread_view: thread_view.clone(),
+                    },
+                    window,
+                    cx,
+                );
            })
+            .log_err();
+
+            anyhow::Ok(())
        })
        .detach();
    }
@@ -1050,7 +1071,7 @@ impl AgentPanel {

        let thread_view = ActiveView::thread(active_thread.clone(), message_editor, window, cx);
        self.set_active_view(thread_view, window, cx);
-        AgentDiff::set_active_thread(&self.workspace, &thread, window, cx);
+        AgentDiff::set_active_thread(&self.workspace, thread.clone(), window, cx);
    }

    pub fn go_back(&mut self, _: &workspace::GoBack, window: &mut Window, cx: &mut Context<Self>) {
@@ -1181,7 +1202,12 @@ impl AgentPanel {
                let thread = thread.read(cx).thread().clone();
                self.workspace
                    .update(cx, |workspace, cx| {
-                        AgentDiffPane::deploy_in_workspace(thread, workspace, window, cx)
+                        AgentDiffPane::deploy_in_workspace(
+                            AgentDiffThread::Native(thread),
+                            workspace,
+                            window,
+                            cx,
+                        )
                    })
                    .log_err();
            }
@@ -1417,6 +1443,8 @@ impl AgentPanel {
            self.active_view = new_view;
        }

+        self.acp_message_history.borrow_mut().reset_position();
+
        self.focus_handle(cx).focus(window);
    }

--- a/crates/agent_ui/src/message_editor.rs
+++ b/crates/agent_ui/src/message_editor.rs
@@ -2,6 +2,7 @@ use std::collections::BTreeMap;
 use std::rc::Rc;
 use std::sync::Arc;

+use crate::agent_diff::AgentDiffThread;
 use crate::agent_model_selector::AgentModelSelector;
 use crate::language_model_selector::ToggleModelSelector;
 use crate::tool_compatibility::{IncompatibleToolsState, IncompatibleToolsTooltip};
@@ -475,9 +476,12 @@ impl MessageEditor {
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
-        if let Ok(diff) =
-            AgentDiffPane::deploy(self.thread.clone(), self.workspace.clone(), window, cx)
-        {
+        if let Ok(diff) = AgentDiffPane::deploy(
+            AgentDiffThread::Native(self.thread.clone()),
+            self.workspace.clone(),
+            window,
+            cx,
+        ) {
            let path_key = multi_buffer::PathKey::for_buffer(&buffer, cx);
            diff.update(cx, |diff, cx| diff.move_to_path(path_key, window, cx));
        }
--- a/crates/assistant_tool/src/action_log.rs
+++ b/crates/assistant_tool/src/action_log.rs
@@ -8,7 +8,7 @@ use language::{Anchor, Buffer, BufferEvent, DiskState, Point, ToPoint};
 use project::{Project, ProjectItem, lsp_store::OpenLspBufferHandle};
 use std::{cmp, ops::Range, sync::Arc};
 use text::{Edit, Patch, Rope};
-use util::RangeExt;
+use util::{RangeExt, ResultExt as _};

 /// Tracks actions performed by tools in a thread
 pub struct ActionLog {
@@ -47,6 +47,10 @@ impl ActionLog {
        self.edited_since_project_diagnostics_check
    }

+    pub fn latest_snapshot(&self, buffer: &Entity<Buffer>) -> Option<text::BufferSnapshot> {
+        Some(self.tracked_buffers.get(buffer)?.snapshot.clone())
+    }
+
    fn track_buffer_internal(
        &mut self,
        buffer: Entity<Buffer>,
@@ -715,6 +719,22 @@ impl ActionLog {
        cx.notify();
    }

+    pub fn reject_all_edits(&mut self, cx: &mut Context<Self>) -> Task<()> {
+        let futures = self.changed_buffers(cx).into_keys().map(|buffer| {
+            let reject = self.reject_edits_in_ranges(buffer, vec![Anchor::MIN..Anchor::MAX], cx);
+
+            async move {
+                reject.await.log_err();
+            }
+        });
+
+        let task = futures::future::join_all(futures);
+
+        cx.spawn(async move |_, _| {
+            task.await;
+        })
+    }
+
    /// Returns the set of buffers that contain edits that haven't been reviewed by the user.
    pub fn changed_buffers(&self, cx: &App) -> BTreeMap<Entity<Buffer>, Entity<BufferDiff>> {
        self.tracked_buffers
--- a/crates/collab/src/stripe_billing.rs
+++ b/crates/collab/src/stripe_billing.rs
@@ -19,8 +19,8 @@ use crate::stripe_client::{
    StripeCustomerId, StripeCustomerUpdate, StripeCustomerUpdateAddress, StripeCustomerUpdateName,
    StripeMeter, StripePrice, StripePriceId, StripeSubscription, StripeSubscriptionId,
    StripeSubscriptionTrialSettings, StripeSubscriptionTrialSettingsEndBehavior,
-    StripeSubscriptionTrialSettingsEndBehaviorMissingPaymentMethod, UpdateSubscriptionItems,
-    UpdateSubscriptionParams,
+    StripeSubscriptionTrialSettingsEndBehaviorMissingPaymentMethod, StripeTaxIdCollection,
+    UpdateSubscriptionItems, UpdateSubscriptionParams,
 };

 pub struct StripeBilling {
@@ -252,6 +252,7 @@ impl StripeBilling {
            name: Some(StripeCustomerUpdateName::Auto),
            shipping: None,
        });
+        params.tax_id_collection = Some(StripeTaxIdCollection { enabled: true });

        let session = self.client.create_checkout_session(params).await?;
        Ok(session.url.context("no checkout session URL")?)
@@ -311,6 +312,7 @@ impl StripeBilling {
            name: Some(StripeCustomerUpdateName::Auto),
            shipping: None,
        });
+        params.tax_id_collection = Some(StripeTaxIdCollection { enabled: true });

        let session = self.client.create_checkout_session(params).await?;
        Ok(session.url.context("no checkout session URL")?)
--- a/crates/collab/src/stripe_client.rs
+++ b/crates/collab/src/stripe_client.rs
@@ -190,6 +190,7 @@ pub struct StripeCreateCheckoutSessionParams<'a> {
    pub success_url: Option<&'a str>,
    pub billing_address_collection: Option<StripeBillingAddressCollection>,
    pub customer_update: Option<StripeCustomerUpdate>,
+    pub tax_id_collection: Option<StripeTaxIdCollection>,
 }

 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
@@ -218,6 +219,11 @@ pub struct StripeCreateCheckoutSessionSubscriptionData {
    pub trial_settings: Option<StripeSubscriptionTrialSettings>,
 }

+#[derive(Debug, PartialEq, Clone)]
+pub struct StripeTaxIdCollection {
+    pub enabled: bool,
+}
+
 #[derive(Debug)]
 pub struct StripeCheckoutSession {
    pub url: Option<String>,
--- a/crates/collab/src/stripe_client/fake_stripe_client.rs
+++ b/crates/collab/src/stripe_client/fake_stripe_client.rs
@@ -14,8 +14,8 @@ use crate::stripe_client::{
    StripeCreateCheckoutSessionSubscriptionData, StripeCreateMeterEventParams,
    StripeCreateSubscriptionParams, StripeCustomer, StripeCustomerId, StripeCustomerUpdate,
    StripeMeter, StripeMeterId, StripePrice, StripePriceId, StripeSubscription,
-    StripeSubscriptionId, StripeSubscriptionItem, StripeSubscriptionItemId, UpdateCustomerParams,
-    UpdateSubscriptionParams,
+    StripeSubscriptionId, StripeSubscriptionItem, StripeSubscriptionItemId, StripeTaxIdCollection,
+    UpdateCustomerParams, UpdateSubscriptionParams,
 };

 #[derive(Debug, Clone)]
@@ -38,6 +38,7 @@ pub struct StripeCreateCheckoutSessionCall {
    pub success_url: Option<String>,
    pub billing_address_collection: Option<StripeBillingAddressCollection>,
    pub customer_update: Option<StripeCustomerUpdate>,
+    pub tax_id_collection: Option<StripeTaxIdCollection>,
 }

 pub struct FakeStripeClient {
@@ -236,6 +237,7 @@ impl StripeClient for FakeStripeClient {
                success_url: params.success_url.map(|url| url.to_string()),
                billing_address_collection: params.billing_address_collection,
                customer_update: params.customer_update,
+                tax_id_collection: params.tax_id_collection,
            });

        Ok(StripeCheckoutSession {
--- a/crates/collab/src/stripe_client/real_stripe_client.rs
+++ b/crates/collab/src/stripe_client/real_stripe_client.rs
@@ -27,8 +27,8 @@ use crate::stripe_client::{
    StripeMeter, StripePrice, StripePriceId, StripePriceRecurring, StripeSubscription,
    StripeSubscriptionId, StripeSubscriptionItem, StripeSubscriptionItemId,
    StripeSubscriptionTrialSettings, StripeSubscriptionTrialSettingsEndBehavior,
-    StripeSubscriptionTrialSettingsEndBehaviorMissingPaymentMethod, UpdateCustomerParams,
-    UpdateSubscriptionParams,
+    StripeSubscriptionTrialSettingsEndBehaviorMissingPaymentMethod, StripeTaxIdCollection,
+    UpdateCustomerParams, UpdateSubscriptionParams,
 };

 pub struct RealStripeClient {
@@ -448,6 +448,7 @@ impl<'a> TryFrom<StripeCreateCheckoutSessionParams<'a>> for CreateCheckoutSessio
            success_url: value.success_url,
            billing_address_collection: value.billing_address_collection.map(Into::into),
            customer_update: value.customer_update.map(Into::into),
+            tax_id_collection: value.tax_id_collection.map(Into::into),
            ..Default::default()
        })
    }
@@ -590,3 +591,11 @@ impl From<StripeCustomerUpdate> for stripe::CreateCheckoutSessionCustomerUpdate
        }
    }
 }
+
+impl From<StripeTaxIdCollection> for stripe::CreateCheckoutSessionTaxIdCollection {
+    fn from(value: StripeTaxIdCollection) -> Self {
+        stripe::CreateCheckoutSessionTaxIdCollection {
+            enabled: value.enabled,
+        }
+    }
+}
--- a/crates/debugger_ui/src/debugger_panel.rs
+++ b/crates/debugger_ui/src/debugger_panel.rs
@@ -36,12 +36,12 @@ use task::{DebugScenario, TaskContext};
 use tree_sitter::{Query, StreamingIterator as _};
 use ui::{ContextMenu, Divider, PopoverMenuHandle, Tooltip, prelude::*};
 use util::{ResultExt, maybe};
-use workspace::SplitDirection;
 use workspace::item::SaveOptions;
 use workspace::{
    Item, Pane, Workspace,
    dock::{DockPosition, Panel, PanelEvent},
 };
+use workspace::{OpenInDebugJson, SplitDirection};
 use zed_actions::ToggleFocus;

 pub enum DebugPanelEvent {
@@ -98,6 +98,25 @@ impl DebugPanel {
                },
            );

+            if let Some(entity) = workspace.weak_handle().upgrade() {
+                let edit_scenario_subscription = cx.subscribe_in(
+                    &entity,
+                    window,
+                    move |this, workspace, OpenInDebugJson { scenario, id }, window, cx| {
+                        let task = this.go_to_scenario_definition(
+                            TaskSourceKind::UserInput,
+                            scenario.clone(),
+                            todo!(),
+                            // *id,
+                            window,
+                            cx,
+                        );
+                        cx.spawn(async move |_, cx| task.await)
+                            .detach_and_log_err(cx);
+                    },
+                );
+            }
+
            Self {
                size: px(300.),
                sessions: vec![],
--- a/crates/debugger_ui/src/new_process_modal.rs
+++ b/crates/debugger_ui/src/new_process_modal.rs
@@ -343,12 +343,6 @@ impl NewProcessModal {
            return;
        }

-        if let NewProcessMode::Launch = &self.mode {
-            if self.configure_mode.read(cx).save_to_debug_json.selected() {
-                self.save_debug_scenario(window, cx);
-            }
-        }
-
        let Some(debugger) = self.debugger.clone() else {
            return;
        };
@@ -806,7 +800,6 @@ pub(super) struct ConfigureMode {
    program: Entity<Editor>,
    cwd: Entity<Editor>,
    stop_on_entry: ToggleState,
-    save_to_debug_json: ToggleState,
 }

 impl ConfigureMode {
@@ -825,7 +818,6 @@ impl ConfigureMode {
            program,
            cwd,
            stop_on_entry: ToggleState::Unselected,
-            save_to_debug_json: ToggleState::Unselected,
        })
    }

--- a/crates/editor/src/code_context_menus.rs
+++ b/crates/editor/src/code_context_menus.rs
@@ -1392,6 +1392,7 @@ impl CodeActionsMenu {
    ) -> AnyElement {
        let actions = self.actions.clone();
        let selected_item = self.selected_item;
+
        let list = uniform_list(
            "code_actions_menu",
            self.actions.len(),
@@ -1438,6 +1439,30 @@ impl CodeActionsMenu {
                                            .overflow_hidden()
                                            .child("debug: ")
                                            .child(scenario.label.clone())
+                                            .child(
+                                                IconButton::new(
+                                                    SharedString::new(format!("edit-{ix}")),
+                                                    IconName::Pencil,
+                                                )
+                                                .on_click(cx.listener({
+                                                    let scenario = scenario.clone();
+                                                    move |editor, _, _window, cx| {
+                                                        if let Some((workspace, Some(id))) =
+                                                            editor.workspace.as_ref()
+                                                        {
+                                                            workspace
+                                                                .update(cx, |_, cx| {
+                                                                    cx.emit(workspace::OpenInDebugJson {
+                                                                        scenario: scenario.clone(),
+                                                                        id: *id,
+                                                                    });
+                                                                })
+                                                                .ok();
+                                                        }
+                                                        cx.stop_propagation();
+                                                    }
+                                                })),
+                                            )
                                            .when(selected, |this| {
                                                this.text_color(colors.text_accent)
                                            }),
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -2836,7 +2836,6 @@ impl EditorElement {
    ) -> Vec<AnyElement> {
        self.editor.update(cx, |editor, cx| {
            let active_task_indicator_row =
-                // TODO: add edit button on the right side of each row in the context menu
                if let Some(crate::CodeContextMenu::CodeActions(CodeActionsMenu {
                    deployed_from,
                    actions,
--- a/crates/git_ui/src/conflict_view.rs
+++ b/crates/git_ui/src/conflict_view.rs
@@ -11,10 +11,7 @@ use gpui::{
 use language::{Anchor, Buffer, BufferId};
 use project::{ConflictRegion, ConflictSet, ConflictSetUpdate, ProjectItem as _};
 use std::{ops::Range, sync::Arc};
-use ui::{
-    ActiveTheme, AnyElement, Element as _, StatefulInteractiveElement, Styled,
-    StyledTypography as _, Window, div, h_flex, rems,
-};
+use ui::{ActiveTheme, Element as _, Styled, Window, prelude::*};
 use util::{ResultExt as _, debug_panic, maybe};

 pub(crate) struct ConflictAddon {
@@ -391,20 +388,15 @@ fn render_conflict_buttons(
    cx: &mut BlockContext,
 ) -> AnyElement {
    h_flex()
-        .h(cx.line_height)
-        .items_end()
-        .ml(cx.margins.gutter.width)
        .id(cx.block_id)
-        .gap_0p5()
+        .h(cx.line_height)
+        .ml(cx.margins.gutter.width)
+        .items_end()
+        .gap_1()
+        .bg(cx.theme().colors().editor_background)
        .child(
-            div()
-                .id("ours")
-                .px_1()
-                .child("Take Ours")
-                .rounded_t(rems(0.2))
-                .text_ui_sm(cx)
-                .hover(|this| this.bg(cx.theme().colors().element_background))
-                .cursor_pointer()
+            Button::new("head", "Use HEAD")
+                .label_size(LabelSize::Small)
                .on_click({
                    let editor = editor.clone();
                    let conflict = conflict.clone();
@@ -423,14 +415,8 @@ fn render_conflict_buttons(
                }),
        )
        .child(
-            div()
-                .id("theirs")
-                .px_1()
-                .child("Take Theirs")
-                .rounded_t(rems(0.2))
-                .text_ui_sm(cx)
-                .hover(|this| this.bg(cx.theme().colors().element_background))
-                .cursor_pointer()
+            Button::new("origin", "Use Origin")
+                .label_size(LabelSize::Small)
                .on_click({
                    let editor = editor.clone();
                    let conflict = conflict.clone();
@@ -449,14 +435,8 @@ fn render_conflict_buttons(
                }),
        )
        .child(
-            div()
-                .id("both")
-                .px_1()
-                .child("Take Both")
-                .rounded_t(rems(0.2))
-                .text_ui_sm(cx)
-                .hover(|this| this.bg(cx.theme().colors().element_background))
-                .cursor_pointer()
+            Button::new("both", "Use Both")
+                .label_size(LabelSize::Small)
                .on_click({
                    let editor = editor.clone();
                    let conflict = conflict.clone();
--- a/crates/settings_ui/src/keybindings.rs
+++ b/crates/settings_ui/src/keybindings.rs
@@ -11,8 +11,8 @@ use fs::Fs;
 use fuzzy::{StringMatch, StringMatchCandidate};
 use gpui::{
    Action, AppContext as _, AsyncApp, ClickEvent, Context, DismissEvent, Entity, EventEmitter,
-    FocusHandle, Focusable, Global, KeyContext, Keystroke, ModifiersChangedEvent, ScrollStrategy,
-    StyledText, Subscription, WeakEntity, actions, div,
+    FocusHandle, Focusable, Global, KeyContext, Keystroke, ModifiersChangedEvent, MouseButton,
+    Point, ScrollStrategy, StyledText, Subscription, WeakEntity, actions, anchored, deferred, div,
 };
 use language::{Language, LanguageConfig, ToOffset as _};
 use settings::{BaseKeymap, KeybindSource, KeymapFile, SettingsAssets};
@@ -21,7 +21,7 @@ use util::ResultExt;

 use ui::{
    ActiveTheme as _, App, Banner, BorrowAppContext, ContextMenu, ParentElement as _, Render,
-    SharedString, Styled as _, Tooltip, Window, prelude::*, right_click_menu,
+    SharedString, Styled as _, Tooltip, Window, prelude::*,
 };
 use workspace::{
    Item, ModalView, SerializableItem, Workspace, notifications::NotifyTaskExt as _,
@@ -71,20 +71,30 @@ pub fn init(cx: &mut App) {

    cx.on_action(|_: &OpenKeymapEditor, cx| {
        workspace::with_active_or_new_workspace(cx, move |workspace, window, cx| {
-            let existing = workspace
-                .active_pane()
-                .read(cx)
-                .items()
-                .find_map(|item| item.downcast::<KeymapEditor>());
+            workspace
+                .with_local_workspace(window, cx, |workspace, window, cx| {
+                    let existing = workspace
+                        .active_pane()
+                        .read(cx)
+                        .items()
+                        .find_map(|item| item.downcast::<KeymapEditor>());

-            if let Some(existing) = existing {
-                workspace.activate_item(&existing, true, true, window, cx);
-            } else {
-                let keymap_editor =
-                    cx.new(|cx| KeymapEditor::new(workspace.weak_handle(), window, cx));
-                workspace.add_item_to_active_pane(Box::new(keymap_editor), None, true, window, cx);
-            }
-        });
+                    if let Some(existing) = existing {
+                        workspace.activate_item(&existing, true, true, window, cx);
+                    } else {
+                        let keymap_editor =
+                            cx.new(|cx| KeymapEditor::new(workspace.weak_handle(), window, cx));
+                        workspace.add_item_to_active_pane(
+                            Box::new(keymap_editor),
+                            None,
+                            true,
+                            window,
+                            cx,
+                        );
+                    }
+                })
+                .detach();
+        })
    });

    cx.observe_new(|_workspace: &mut Workspace, window, cx| {
@@ -187,13 +197,19 @@ struct ConflictState {
 }

 impl ConflictState {
-    fn new(key_bindings: &Vec<ProcessedKeybinding>) -> Self {
+    fn new(key_bindings: &[ProcessedKeybinding]) -> Self {
        let mut action_keybind_mapping: HashMap<_, Vec<usize>> = HashMap::default();

        key_bindings
            .iter()
            .enumerate()
-            .filter(|(_, binding)| !binding.keystroke_text.is_empty())
+            .filter(|(_, binding)| {
+                !binding.keystroke_text.is_empty()
+                    && binding
+                        .source
+                        .as_ref()
+                        .is_some_and(|source| matches!(source.0, KeybindSource::User))
+            })
            .for_each(|(index, binding)| {
                action_keybind_mapping
                    .entry(binding.get_action_mapping())
@@ -249,6 +265,7 @@ struct KeymapEditor {
    filter_editor: Entity<Editor>,
    keystroke_editor: Entity<KeystrokeInput>,
    selected_index: Option<usize>,
+    context_menu: Option<(Entity<ContextMenu>, Point<Pixels>, Subscription)>,
 }

 impl EventEmitter<()> for KeymapEditor {}
@@ -261,8 +278,6 @@ impl Focusable for KeymapEditor {

 impl KeymapEditor {
    fn new(workspace: WeakEntity<Workspace>, window: &mut Window, cx: &mut Context<Self>) -> Self {
-        let focus_handle = cx.focus_handle();
-
        let _keymap_subscription =
            cx.observe_global::<KeymapEventChannel>(Self::update_keybindings);
        let table_interaction_state = TableInteractionState::new(window, cx);
@@ -305,12 +320,13 @@ impl KeymapEditor {
            search_mode: SearchMode::default(),
            string_match_candidates: Arc::new(vec![]),
            matches: vec![],
-            focus_handle: focus_handle.clone(),
+            focus_handle: cx.focus_handle(),
            _keymap_subscription,
            table_interaction_state,
            filter_editor,
            keystroke_editor,
            selected_index: None,
+            context_menu: None,
        };

        this.update_keybindings(cx);
@@ -587,6 +603,68 @@ impl KeymapEditor {
            .and_then(|keybind_index| self.keybindings.get(keybind_index))
    }

+    fn select_index(&mut self, index: usize, cx: &mut Context<Self>) {
+        if self.selected_index != Some(index) {
+            self.selected_index = Some(index);
+            cx.notify();
+        }
+    }
+
+    fn create_context_menu(
+        &mut self,
+        position: Point<Pixels>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.context_menu = self.selected_binding().map(|selected_binding| {
+            let selected_binding_has_no_context = selected_binding
+                .context
+                .as_ref()
+                .and_then(KeybindContextString::local)
+                .is_none();
+
+            let selected_binding_is_unbound = selected_binding.ui_key_binding.is_none();
+
+            let context_menu = ContextMenu::build(window, cx, |menu, _window, _cx| {
+                menu.action_disabled_when(
+                    selected_binding_is_unbound,
+                    "Edit",
+                    Box::new(EditBinding),
+                )
+                .action("Create", Box::new(CreateBinding))
+                .action("Copy action", Box::new(CopyAction))
+                .action_disabled_when(
+                    selected_binding_has_no_context,
+                    "Copy Context",
+                    Box::new(CopyContext),
+                )
+            });
+
+            let context_menu_handle = context_menu.focus_handle(cx);
+            window.defer(cx, move |window, _cx| window.focus(&context_menu_handle));
+            let subscription = cx.subscribe_in(
+                &context_menu,
+                window,
+                |this, _, _: &DismissEvent, window, cx| {
+                    this.dismiss_context_menu(window, cx);
+                },
+            );
+            (context_menu, position, subscription)
+        });
+
+        cx.notify();
+    }
+
+    fn dismiss_context_menu(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        self.context_menu.take();
+        window.focus(&self.focus_handle);
+        cx.notify();
+    }
+
+    fn context_menu_deployed(&self) -> bool {
+        self.context_menu.is_some()
+    }
+
    fn select_next(&mut self, _: &menu::SelectNext, window: &mut Window, cx: &mut Context<Self>) {
        if let Some(selected) = self.selected_index {
            let selected = selected + 1;
@@ -969,6 +1047,7 @@ impl Render for KeymapEditor {
                        "keymap-editor-table",
                        row_count,
                        cx.processor(move |this, range: Range<usize>, _window, cx| {
+                            let context_menu_deployed = this.context_menu_deployed();
                            range
                                .filter_map(|index| {
                                    let candidate_id = this.matches.get(index)?.candidate_id;
@@ -977,21 +1056,23 @@ impl Render for KeymapEditor {
                                    let action = div()
                                        .child(binding.action_name.clone())
                                        .id(("keymap action", index))
-                                        .tooltip({
-                                            let action_name = binding.action_name.clone();
-                                            let action_docs = binding.action_docs;
-                                            move |_, cx| {
-                                                let action_tooltip = Tooltip::new(
-                                                    command_palette::humanize_action_name(
-                                                        &action_name,
-                                                    ),
-                                                );
-                                                let action_tooltip = match action_docs {
-                                                    Some(docs) => action_tooltip.meta(docs),
-                                                    None => action_tooltip,
-                                                };
-                                                cx.new(|_| action_tooltip).into()
-                                            }
+                                        .when(!context_menu_deployed, |this| {
+                                            this.tooltip({
+                                                let action_name = binding.action_name.clone();
+                                                let action_docs = binding.action_docs;
+                                                move |_, cx| {
+                                                    let action_tooltip = Tooltip::new(
+                                                        command_palette::humanize_action_name(
+                                                            &action_name,
+                                                        ),
+                                                    );
+                                                    let action_tooltip = match action_docs {
+                                                        Some(docs) => action_tooltip.meta(docs),
+                                                        None => action_tooltip,
+                                                    };
+                                                    cx.new(|_| action_tooltip).into()
+                                                }
+                                            })
                                        })
                                        .into_any_element();
                                    let keystrokes = binding.ui_key_binding.clone().map_or(
@@ -1009,12 +1090,24 @@ impl Render for KeymapEditor {
                                            }
                                        }
                                    };
-                                    let context = binding
-                                        .context
-                                        .clone()
-                                        .map_or(gpui::Empty.into_any_element(), |context| {
-                                            context.into_any_element()
-                                        });
+                                    let context = binding.context.clone().map_or(
+                                        gpui::Empty.into_any_element(),
+                                        |context| {
+                                            let is_local = context.local().is_some();
+
+                                            div()
+                                                .id(("keymap context", index))
+                                                .child(context.clone())
+                                                .when(is_local && !context_menu_deployed, |this| {
+                                                    this.tooltip(Tooltip::element({
+                                                        move |_, _| {
+                                                            context.clone().into_any_element()
+                                                        }
+                                                    }))
+                                                })
+                                                .into_any_element()
+                                        },
+                                    );
                                    let source = binding
                                        .source
                                        .clone()
@@ -1037,9 +1130,30 @@ impl Render for KeymapEditor {

                            let row = row
                                .id(("keymap-table-row", row_index))
+                                .on_any_mouse_down(cx.listener(
+                                    move |this,
+                                          mouse_down_event: &gpui::MouseDownEvent,
+                                          window,
+                                          cx| {
+                                        match mouse_down_event.button {
+                                            MouseButton::Left => {
+                                                this.select_index(row_index, cx);
+                                            }
+
+                                            MouseButton::Right => {
+                                                this.select_index(row_index, cx);
+                                                this.create_context_menu(
+                                                    mouse_down_event.position,
+                                                    window,
+                                                    cx,
+                                                );
+                                            }
+                                            _ => {}
+                                        }
+                                    },
+                                ))
                                .on_click(cx.listener(
                                    move |this, event: &ClickEvent, window, cx| {
-                                        this.selected_index = Some(row_index);
                                        if event.up.click_count == 2 {
                                            this.open_edit_keybinding_modal(false, window, cx);
                                        }
@@ -1053,18 +1167,23 @@ impl Render for KeymapEditor {
                                    row.border_color(cx.theme().colors().panel_focused_border)
                                });

-                            right_click_menu(("keymap-table-row-menu", row_index))
-                                .trigger(move |_, _, _| row)
-                                .menu({
-                                    let this = cx.weak_entity();
-                                    move |window, cx| {
-                                        build_keybind_context_menu(&this, row_index, window, cx)
-                                    }
-                                })
-                                .into_any_element()
+                            row.into_any_element()
                        }),
                    ),
            )
+            .on_scroll_wheel(cx.listener(|this, _, _, cx| {
+                this.context_menu.take();
+                cx.notify();
+            }))
+            .children(self.context_menu.as_ref().map(|(menu, position, _)| {
+                deferred(
+                    anchored()
+                        .position(*position)
+                        .anchor(gpui::Corner::TopLeft)
+                        .child(menu.clone()),
+                )
+                .with_priority(1)
+            }))
    }
 }

@@ -1877,53 +1996,6 @@ impl Render for KeystrokeInput {
    }
 }

-fn build_keybind_context_menu(
-    this: &WeakEntity<KeymapEditor>,
-    item_idx: usize,
-    window: &mut Window,
-    cx: &mut App,
-) -> Entity<ContextMenu> {
-    ContextMenu::build(window, cx, |menu, _window, cx| {
-        let selected_binding = this
-            .update(cx, |this, _cx| {
-                this.selected_index = Some(item_idx);
-                this.selected_binding().cloned()
-            })
-            .ok()
-            .flatten();
-
-        let Some(selected_binding) = selected_binding else {
-            return menu;
-        };
-
-        let selected_binding_has_no_context = selected_binding
-            .context
-            .as_ref()
-            .and_then(KeybindContextString::local)
-            .is_none();
-
-        let selected_binding_is_unbound_action = selected_binding.ui_key_binding.is_none();
-
-        menu.action_disabled_when(
-            selected_binding_is_unbound_action,
-            "Edit",
-            Box::new(EditBinding),
-        )
-        .action("Create", Box::new(CreateBinding))
-        .action_disabled_when(
-            selected_binding_is_unbound_action,
-            "Delete",
-            Box::new(DeleteBinding),
-        )
-        .action("Copy action", Box::new(CopyAction))
-        .action_disabled_when(
-            selected_binding_has_no_context,
-            "Copy Context",
-            Box::new(CopyContext),
-        )
-    })
-}
-
 fn collect_contexts_from_assets() -> Vec<SharedString> {
    let mut keymap_assets = vec![
        util::asset_str::<SettingsAssets>(settings::DEFAULT_KEYMAP_PATH),
--- a/crates/terminal_view/src/terminal_element.rs
+++ b/crates/terminal_view/src/terminal_element.rs
@@ -127,7 +127,7 @@ impl BatchedTextRun {
        cx: &mut App,
    ) {
        let pos = Point::new(
-            (origin.x + self.start_point.column as f32 * dimensions.cell_width).floor(),
+            origin.x + self.start_point.column as f32 * dimensions.cell_width,
            origin.y + self.start_point.line as f32 * dimensions.line_height,
        );

--- a/crates/ui/src/components/tooltip.rs
+++ b/crates/ui/src/components/tooltip.rs
@@ -1,3 +1,5 @@
+use std::rc::Rc;
+
 use gpui::{Action, AnyElement, AnyView, AppContext as _, FocusHandle, IntoElement, Render};
 use settings::Settings;
 use theme::ThemeSettings;
@@ -7,15 +9,36 @@ use crate::{Color, KeyBinding, Label, LabelSize, StyledExt, h_flex, v_flex};

 #[derive(RegisterComponent)]
 pub struct Tooltip {
-    title: SharedString,
+    title: Title,
    meta: Option<SharedString>,
    key_binding: Option<KeyBinding>,
 }

+#[derive(Clone, IntoElement)]
+enum Title {
+    Str(SharedString),
+    Callback(Rc<dyn Fn(&mut Window, &mut App) -> AnyElement>),
+}
+
+impl From<SharedString> for Title {
+    fn from(value: SharedString) -> Self {
+        Title::Str(value)
+    }
+}
+
+impl RenderOnce for Title {
+    fn render(self, window: &mut Window, cx: &mut App) -> impl gpui::IntoElement {
+        match self {
+            Title::Str(title) => title.into_any_element(),
+            Title::Callback(element) => element(window, cx),
+        }
+    }
+}
+
 impl Tooltip {
    pub fn simple(title: impl Into<SharedString>, cx: &mut App) -> AnyView {
        cx.new(|_| Self {
-            title: title.into(),
+            title: Title::Str(title.into()),
            meta: None,
            key_binding: None,
        })
@@ -26,7 +49,7 @@ impl Tooltip {
        let title = title.into();
        move |_, cx| {
            cx.new(|_| Self {
-                title: title.clone(),
+                title: title.clone().into(),
                meta: None,
                key_binding: None,
            })
@@ -34,15 +57,15 @@ impl Tooltip {
        }
    }

-    pub fn for_action_title<Title: Into<SharedString>>(
-        title: Title,
+    pub fn for_action_title<T: Into<SharedString>>(
+        title: T,
        action: &dyn Action,
-    ) -> impl Fn(&mut Window, &mut App) -> AnyView + use<Title> {
+    ) -> impl Fn(&mut Window, &mut App) -> AnyView + use<T> {
        let title = title.into();
        let action = action.boxed_clone();
        move |window, cx| {
            cx.new(|cx| Self {
-                title: title.clone(),
+                title: Title::Str(title.clone()),
                meta: None,
                key_binding: KeyBinding::for_action(action.as_ref(), window, cx),
            })
@@ -60,7 +83,7 @@ impl Tooltip {
        let focus_handle = focus_handle.clone();
        move |window, cx| {
            cx.new(|cx| Self {
-                title: title.clone(),
+                title: Title::Str(title.clone()),
                meta: None,
                key_binding: KeyBinding::for_action_in(action.as_ref(), &focus_handle, window, cx),
            })
@@ -75,7 +98,7 @@ impl Tooltip {
        cx: &mut App,
    ) -> AnyView {
        cx.new(|cx| Self {
-            title: title.into(),
+            title: Title::Str(title.into()),
            meta: None,
            key_binding: KeyBinding::for_action(action, window, cx),
        })
@@ -90,7 +113,7 @@ impl Tooltip {
        cx: &mut App,
    ) -> AnyView {
        cx.new(|cx| Self {
-            title: title.into(),
+            title: title.into().into(),
            meta: None,
            key_binding: KeyBinding::for_action_in(action, focus_handle, window, cx),
        })
@@ -105,7 +128,7 @@ impl Tooltip {
        cx: &mut App,
    ) -> AnyView {
        cx.new(|cx| Self {
-            title: title.into(),
+            title: title.into().into(),
            meta: Some(meta.into()),
            key_binding: action.and_then(|action| KeyBinding::for_action(action, window, cx)),
        })
@@ -121,7 +144,7 @@ impl Tooltip {
        cx: &mut App,
    ) -> AnyView {
        cx.new(|cx| Self {
-            title: title.into(),
+            title: title.into().into(),
            meta: Some(meta.into()),
            key_binding: action
                .and_then(|action| KeyBinding::for_action_in(action, focus_handle, window, cx)),
@@ -131,12 +154,35 @@ impl Tooltip {

    pub fn new(title: impl Into<SharedString>) -> Self {
        Self {
-            title: title.into(),
+            title: title.into().into(),
            meta: None,
            key_binding: None,
        }
    }

+    pub fn new_element(title: impl Fn(&mut Window, &mut App) -> AnyElement + 'static) -> Self {
+        Self {
+            title: Title::Callback(Rc::new(title)),
+            meta: None,
+            key_binding: None,
+        }
+    }
+
+    pub fn element(
+        title: impl Fn(&mut Window, &mut App) -> AnyElement + 'static,
+    ) -> impl Fn(&mut Window, &mut App) -> AnyView {
+        let title = Title::Callback(Rc::new(title));
+        move |_, cx| {
+            let title = title.clone();
+            cx.new(|_| Self {
+                title: title,
+                meta: None,
+                key_binding: None,
+            })
+            .into()
+        }
+    }
+
    pub fn meta(mut self, meta: impl Into<SharedString>) -> Self {
        self.meta = Some(meta.into());
        self
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -1092,6 +1092,14 @@ pub struct Workspace {

 impl EventEmitter<Event> for Workspace {}

+#[derive(Clone)]
+pub struct OpenInDebugJson {
+    pub scenario: DebugScenario,
+    pub id: WorkspaceId,
+}
+
+impl EventEmitter<OpenInDebugJson> for Workspace {}
+
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct ViewId {
    pub creator: CollaboratorId,
--- a/crates/zed/build.rs
+++ b/crates/zed/build.rs
@@ -50,12 +50,12 @@ fn main() {
            println!("cargo:rustc-link-arg=/stack:{}", 8 * 1024 * 1024);
        }

-        let release_channel = option_env!("RELEASE_CHANNEL").unwrap_or("nightly");
-
+        let release_channel = option_env!("RELEASE_CHANNEL").unwrap_or("dev");
        let icon = match release_channel {
            "stable" => "resources/windows/app-icon.ico",
            "preview" => "resources/windows/app-icon-preview.ico",
            "nightly" => "resources/windows/app-icon-nightly.ico",
+            "dev" => "resources/windows/app-icon-dev.ico",
            _ => "resources/windows/app-icon-dev.ico",
        };
        let icon = std::path::Path::new(icon);
--- a/crates/zed/resources/windows/app-icon-dev.ico
+++ b/crates/zed/resources/windows/app-icon-dev.ico
--- a/crates/zed/resources/windows/app-icon-nightly.ico
+++ b/crates/zed/resources/windows/app-icon-nightly.ico
--- a/crates/zed/resources/windows/app-icon-preview.ico
+++ b/crates/zed/resources/windows/app-icon-preview.ico
--- a/crates/zed/resources/windows/app-icon.ico
+++ b/crates/zed/resources/windows/app-icon.ico
--- a/script/bundle-windows.ps1
+++ b/script/bundle-windows.ps1
@@ -167,7 +167,7 @@ function BuildInstaller {
        }
        "dev" {
            $appId = "{{8357632E-24A4-4F32-BA97-E575B4D1FE5D}"
-            $appIconName = "app-icon-nightly"
+            $appIconName = "app-icon-dev"
            $appName = "Zed Dev"
            $appDisplayName = "Zed Dev"
            $appSetupName = "ZedEditorUserSetup-x64-$env:RELEASE_VERSION-dev"
Author	SHA1	Message	Date
Julia Ryan	bded0e12f4	wip	2025-07-22 14:08:11 -07:00
Julia Ryan	124b4645c4	switch from action to event	2025-07-18 14:34:31 -07:00
Julia Ryan	b24a30916a	wip: start adding action	2025-07-18 14:34:31 -07:00
Julia Ryan	05e0a812c4	Add gutter runnable edit buttons	2025-07-18 14:34:31 -07:00
Agus Zubiaga	d0e01dbd8f	Improve thread message history (#34299 ) - Keep history across threads - Reset position when edited Release Notes: - N/A --------- Co-authored-by: Ben Brandt <benjamin.j.brandt@gmail.com>	2025-07-11 16:24:41 +00:00
Danilo Leal	d65855c4a1	git: Change merge conflict button labels (#34297 ) Following feedback that "Take Ours" and "Take Theirs" was confusing, leading to users not knowing what exactly happened with each of these buttons. It's now "Use HEAD" and "Use Origin", which also match what is written in Git markers, helping parse them out more easily. Future improvement is to have the actual branch target name in the "Use Origin" button. Release Notes: - git: Improved merge conflict buttons clarity by changing labels to "Use HEAD" and "Use Origin".	2025-07-11 13:15:06 -03:00
Alisina Bahadori	70351360d7	Fix bad kerning in integrated terminal (#34292 ) Closes #16869 Release Notes: - (preview only): Fix bad kerning in integrated terminal.	2025-07-11 09:50:48 -06:00
Conrad Irwin	993e0f55ec	ACP follow (#34235 ) Closes #ISSUE Release Notes: - N/A --------- Co-authored-by: Agus Zubiaga <agus@zed.dev> Co-authored-by: Anthony Eid <hello@anthonyeid.me> Co-authored-by: Ben Brandt <benjamin.j.brandt@gmail.com>	2025-07-11 12:38:42 -03:00
Ben Kunkle	496bf0ec43	keymap_ui: Ensure keymap UI opens in local workspace (#34291 ) Closes #ISSUE Use `workspace.with_local_workspace` to ensure the keymap UI is opened in a local workspace, even in remote. This was tested by removing the feature flag handling code, as with the feature flag logic the action does not appear which is likely a bug. Release Notes: - N/A or Added/Fixed/Improved ...	2025-07-11 11:32:59 -04:00
morgankrey	c09f484ec4	collab: Add ability to add tax ID during Stripe Checkout (#34246 ) ### 1. Added Tax ID Collection Types - Created a new `StripeTaxIdCollection` struct with an `enabled` field - Added `tax_id_collection` field to `StripeCreateCheckoutSessionParams` ### 2. Updated the Stripe Client Interface - Modified the real Stripe client to handle tax ID collection conversion - Updated the fake Stripe client for testing purposes - Added proper imports across all affected files ### 3. Enabled Tax ID Collection in Checkout Sessions - Both `checkout_with_zed_pro` and `checkout_with_zed_pro_trial` methods now enable tax ID collection - The implementation correctly sets `tax_id_collection.enabled = true` for all checkout sessions ### 4. Key Implementation Details - Tax ID collection will be shown to new customers and existing customers without tax IDs - Collected tax IDs will be automatically saved to the customer's `tax_ids` array in Stripe - Business names will be saved to the customer's `name` property - The existing `customer_update.name = auto` setting ensures compatibility with tax ID collection Release Notes: - N/A	2025-07-11 11:26:36 -04:00
Finn Evers	a58a75c0f6	keymap_ui: Hide tooltips when context menu is shown (#34286 ) This PR ensures tooltips are dismissed/not shown once the context menu is opened. It also ensures the context menu is dismissed once the list is scrolled. Release Notes: - N/A	2025-07-11 15:17:34 +00:00
Ben Kunkle	d1a6c5d494	keymap_ui: Hover tooltip for context (#34290 ) Closes #ISSUE Ideally the tooltip would only appear if the context was overflowing it's column, but for now, we just unconditionally show a tooltip so that long contexts can be seen. This PR also includes a change to the tooltip element, allowing for tooltips with non-text contents which is used here for syntax highlighting Release Notes: - N/A or Added/Fixed/Improved ... Co-authored-by: Anthony <anthony@zed.dev>	2025-07-11 10:54:08 -04:00
Peter Tripp	10028aaae8	Ensure *.json recognized as JSONC if checkout folder not `zed` (#34289 ) Follow-up to: https://github.com/zed-industries/zed/pull/33410 Release Notes: - N/A	2025-07-11 14:25:09 +00:00
Ben Kunkle	3b9bb521f4	keymap_ui: Only show conflicts between user bindings (#34284 ) Closes #ISSUE This makes it so conflicts are only shown between user bindings. User bindings that override bindings in the Vim, Base, and Default keymaps are not identified as conflicts Release Notes: - N/A or Added/Fixed/Improved ... Co-authored-by: Anthony <anthony@zed.dev>	2025-07-11 13:51:21 +00:00
Anthony Eid	7eb739d489	Add initial support for search by keystroke to keybinding editor (#34274 ) This PR adds preliminary support for searching keybindings by keystrokes in the keybinding editor. Release Notes: - N/A	2025-07-11 09:29:29 -04:00
localcc	b4cbea50bb	Fix icon size on Windows (#34277 ) Closes #34122 Release Notes: - N/A	2025-07-11 15:09:10 +02:00