helix paste (wip)

helix yank (wip)
Handle Motion::CurrentLine in vim Mode::HelixNormal
2025-04-01 16:32:42 -05:00 · 2025-04-01 16:32:31 -05:00 · 2025-04-01 16:28:35 -05:00
393 changed files with 12659 additions and 16725 deletions
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -14,10 +14,10 @@ linker = "clang"
 rustflags = ["-C", "link-arg=-fuse-ld=mold"]

 [target.aarch64-apple-darwin]
-rustflags = ["-C", "link-args=-all_load"]
+rustflags = ["-C", "link-args=-Objc -all_load"]

 [target.x86_64-apple-darwin]
-rustflags = ["-C", "link-args=-all_load"]
+rustflags = ["-C", "link-args=-Objc -all_load"]

 [target.'cfg(target_os = "windows")']
 rustflags = [
--- a/.config/hakari.toml
+++ b/.config/hakari.toml
@@ -1,43 +0,0 @@
-# This file contains settings for `cargo hakari`.
-# See https://docs.rs/cargo-hakari/latest/cargo_hakari/config for a full list of options.
-
-hakari-package = "workspace-hack"
-
-resolver = "2"
-dep-format-version = "4"
-workspace-hack-line-style = "workspace-dotted"
-
-# this should be the same list as "targets" in ../rust-toolchain.toml
-platforms = [
-    "x86_64-apple-darwin",
-    "aarch64-apple-darwin",
-    "x86_64-unknown-linux-gnu",
-    "aarch64-unknown-linux-gnu",
-    "x86_64-pc-windows-msvc",
-    "x86_64-unknown-linux-musl", # remote server
-]
-
-[traversal-excludes]
-workspace-members = [
-    "remote_server",
-]
-third-party = [
-    { name = "reqwest", version = "0.11.27" },
-]
-
-[final-excludes]
-workspace-members = [
-    "zed_extension_api",
-
-    # exclude all extensions
-    "zed_emmet",
-    "zed_glsl",
-    "zed_html",
-    "perplexity",
-    "zed_proto",
-    "zed_ruff",
-    "slash_commands_example",
-    "zed_snippets",
-    "zed_test_extension",
-    "zed_toml",
-]
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -110,37 +110,6 @@ jobs:
          input: "crates/proto/proto/"
          against: "https://github.com/${GITHUB_REPOSITORY}.git#branch=${BUF_BASE_BRANCH},subdir=crates/proto/proto/"

-  workspace_hack:
-    timeout-minutes: 60
-    name: Check workspace-hack crate
-    needs: [job_spec]
-    if: github.repository_owner == 'zed-industries'
-    runs-on:
-      - buildjet-8vcpu-ubuntu-2204
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
-      - name: Add Rust to the PATH
-        run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
-      - name: Install cargo-hakari
-        uses: clechasseur/rs-cargo@8435b10f6e71c2e3d4d3b7573003a8ce4bfc6386 # v2
-        with:
-          command: install
-          args: cargo-hakari@0.9.35
-
-      - name: Check workspace-hack Cargo.toml is up-to-date
-        run: |
-          cargo hakari generate --diff || {
-            echo "To fix, run script/update-workspace-hack";
-            false
-          }
-      - name: Check all crates depend on workspace-hack
-        run: |
-          cargo hakari manage-deps --dry-run || {
-            echo "To fix, run script/update-workspace-hack"
-            false
-          }
-
  style:
    timeout-minutes: 60
    name: Check formatting and spelling
@@ -463,7 +432,6 @@ jobs:
      - job_spec
      - style
      - migration_checks
-      - workspace_hack
      - linux_tests
      - build_remote_server
      - macos_tests
--- a/.github/workflows/release_nightly.yml
+++ b/.github/workflows/release_nightly.yml
@@ -184,6 +184,9 @@ jobs:
          - os: arm Mac
            runner: [macOS, ARM64, test]
            install_nix: false
+          - os: arm Linux
+            runner: buildjet-16vcpu-ubuntu-2204-arm
+            install_nix: true
    if: github.repository_owner == 'zed-industries'
    runs-on: ${{ matrix.system.runner }}
    needs: tests
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,11 +2,11 @@
 resolver = "2"
 members = [
    "crates/activity_indicator",
-    "crates/agent",
    "crates/anthropic",
    "crates/askpass",
    "crates/assets",
    "crates/assistant",
+    "crates/assistant2",
    "crates/assistant_context_editor",
    "crates/assistant_eval",
    "crates/assistant_settings",
@@ -192,7 +192,6 @@ members = [
    # Tooling
    #

-    "tooling/workspace-hack",
    "tooling/xtask",
 ]
 default-members = ["crates/zed"]
@@ -208,12 +207,12 @@ edition = "2024"
 #

 activity_indicator = { path = "crates/activity_indicator" }
-agent = { path = "crates/agent" }
 ai = { path = "crates/ai" }
 anthropic = { path = "crates/anthropic" }
 askpass = { path = "crates/askpass" }
 assets = { path = "crates/assets" }
 assistant = { path = "crates/assistant" }
+assistant2 = { path = "crates/assistant2" }
 assistant_context_editor = { path = "crates/assistant_context_editor" }
 assistant_eval = { path = "crates/assistant_eval" }
 assistant_settings = { path = "crates/assistant_settings" }
@@ -399,11 +398,11 @@ async-trait = "0.1"
 async-tungstenite = "0.28"
 async-watch = "0.3.1"
 async_zip = { version = "0.0.17", features = ["deflate", "deflate64"] }
-aws-config = { version = "1.6.1", features = ["behavior-version-latest"] }
-aws-credential-types = { version = "1.2.2", features = ["hardcoded-credentials"] }
-aws-sdk-bedrockruntime = { version = "1.80.0", features = ["behavior-version-latest"] }
-aws-smithy-runtime-api = { version = "1.7.4", features = ["http-1x", "client"] }
-aws-smithy-types = { version = "1.3.0", features = ["http-body-1-x"] }
+aws-config = { version = "1.5.16", features = ["behavior-version-latest"] }
+aws-credential-types = { version = "1.2.1", features = ["hardcoded-credentials"] }
+aws-sdk-bedrockruntime = { version = "1.73.0", features = ["behavior-version-latest"] }
+aws-smithy-runtime-api = { version = "1.7.3", features = ["http-1x", "client"] }
+aws-smithy-types = { version = "1.2.13", features = ["http-body-1-x"] }
 base64 = "0.22"
 bitflags = "2.6.0"
 blade-graphics = { git = "https://github.com/kvark/blade", rev = "b16f5c7bd873c7126f48c82c39e7ae64602ae74f" }
@@ -569,7 +568,7 @@ tree-sitter-md = { git = "https://github.com/tree-sitter-grammars/tree-sitter-ma
 tree-sitter-python = "0.23"
 tree-sitter-regex = "0.24"
 tree-sitter-ruby = "0.23"
-tree-sitter-rust = "0.24"
+tree-sitter-rust = "0.23"
 tree-sitter-typescript = "0.23"
 tree-sitter-yaml = { git = "https://github.com/zed-industries/tree-sitter-yaml", rev = "baff0b51c64ef6a1fb1f8390f3ad6015b83ec13a" }
 unicase = "2.6"
@@ -579,7 +578,6 @@ unicode-script = "0.5.7"
 url = "2.2"
 urlencoding = "2.1.2"
 uuid = { version = "1.1.2", features = ["v4", "v5", "v7", "serde"] }
-walkdir = "2.3"
 wasmparser = "0.221"
 wasm-encoder = "0.221"
 wasmtime = { version = "29", default-features = false, features = [
@@ -592,7 +590,6 @@ wasmtime = { version = "29", default-features = false, features = [
 wasmtime-wasi = "29"
 which = "6.0.0"
 wit-component = "0.221"
-workspace-hack = "0.1.0"
 zed_llm_client = "0.4"
 zstd = "0.11"
 metal = "0.29"
@@ -660,11 +657,6 @@ features = [
 [patch.crates-io]
 cpal = { git = "https://github.com/zed-industries/cpal", rev = "fd8bc2fd39f1f5fdee5a0690656caff9a26d9d50" }
 real-async-tls = { git = "https://github.com/zed-industries/async-tls", rev = "1e759a4b5e370f87dc15e40756ac4f8815b61d9d", package = "async-tls" }
-notify = { git = "https://github.com/zed-industries/notify.git", rev = "bbb9ea5ae52b253e095737847e367c30653a2e96" }
-notify-types = { git = "https://github.com/zed-industries/notify.git", rev = "bbb9ea5ae52b253e095737847e367c30653a2e96" }
-
-# Makes the workspace hack crate refer to the local one, but only when you're building locally
-workspace-hack = { path = "tooling/workspace-hack" }

 [profile.dev]
 split-debuginfo = "unpacked"
@@ -778,4 +770,4 @@ let_underscore_future = "allow"
 too_many_arguments = "allow"

 [workspace.metadata.cargo-machete]
-ignored = ["bindgen", "cbindgen", "prost_build", "serde", "component", "linkme", "workspace-hack"]
+ignored = ["bindgen", "cbindgen", "prost_build", "serde", "component", "linkme"]
--- a/assets/icons/check_double.svg
+++ b/assets/icons/check_double.svg
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-check-check-icon lucide-check-check"><path d="M18 6 7 17l-5-5"/><path d="m22 10-7.5 7.5L13 16"/></svg>
--- a/assets/icons/forward_arrow.svg
+++ b/assets/icons/forward_arrow.svg
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-forward-icon lucide-forward"><polyline points="15 17 20 12 15 7"/><path d="M4 18v-2a4 4 0 0 1 4-4h12"/></svg>
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -138,7 +138,7 @@
    }
  },
  {
-    "context": "Editor && !agent_diff",
+    "context": "Editor && !assistant_diff",
    "bindings": {
      "ctrl-k ctrl-r": "git::Restore",
      "ctrl-alt-y": "git::ToggleStaged",
@@ -147,10 +147,10 @@
    }
  },
  {
-    "context": "AgentDiff",
+    "context": "AssistantDiff",
    "bindings": {
-      "ctrl-y": "agent::Keep",
-      "ctrl-k ctrl-r": "agent::Reject"
+      "ctrl-y": "assistant2::ToggleKeep",
+      "ctrl-k ctrl-r": "assistant2::Reject"
    }
  },
  {
@@ -594,6 +594,13 @@
      "ctrl-:": "editor::ToggleInlayHints"
    }
  },
+  {
+    "context": "ProposedChangesEditor",
+    "bindings": {
+      "ctrl-shift-y": "editor::ApplyDiffHunk",
+      "ctrl-alt-a": "editor::ApplyAllDiffHunks"
+    }
+  },
  {
    "context": "Editor && jupyter && !ContextEditor",
    "bindings": {
@@ -618,34 +625,34 @@
    }
  },
  {
-    "context": "AgentPanel",
+    "context": "AssistantPanel2",
    "bindings": {
-      "ctrl-n": "agent::NewThread",
-      "new": "agent::NewThread",
-      "ctrl-alt-n": "agent::NewPromptEditor",
-      "ctrl-shift-h": "agent::OpenHistory",
-      "ctrl-alt-c": "agent::OpenConfiguration",
-      "ctrl-i": "agent::ToggleProfileSelector",
+      "ctrl-n": "assistant2::NewThread",
+      "new": "assistant2::NewThread",
+      "ctrl-alt-n": "assistant2::NewPromptEditor",
+      "ctrl-shift-h": "assistant2::OpenHistory",
+      "ctrl-alt-c": "assistant2::OpenConfiguration",
+      "ctrl-i": "assistant2::ToggleProfileSelector",
      "ctrl-alt-/": "assistant::ToggleModelSelector",
-      "ctrl-shift-a": "agent::ToggleContextPicker",
-      "ctrl-e": "agent::ChatMode",
-      "ctrl-alt-e": "agent::RemoveAllContext"
+      "ctrl-shift-a": "assistant2::ToggleContextPicker",
+      "ctrl-e": "assistant2::ChatMode",
+      "ctrl-alt-e": "assistant2::RemoveAllContext"
    }
  },
  {
-    "context": "AgentPanel && prompt_editor",
+    "context": "AssistantPanel2 && prompt_editor",
    "use_key_equivalents": true,
    "bindings": {
-      "cmd-n": "agent::NewPromptEditor",
-      "cmd-alt-t": "agent::NewThread"
+      "cmd-n": "assistant2::NewPromptEditor",
+      "cmd-alt-t": "assistant2::NewThread"
    }
  },
  {
    "context": "MessageEditor > Editor",
    "bindings": {
-      "enter": "agent::Chat",
-      "ctrl-i": "agent::ToggleProfileSelector",
-      "shift-ctrl-r": "agent::OpenAgentDiff"
+      "enter": "assistant2::Chat",
+      "ctrl-i": "assistant2::ToggleProfileSelector",
+      "shift-ctrl-r": "assistant2::OpenAssistantDiff"
    }
  },
  {
@@ -657,30 +664,21 @@
      "alt-enter": "editor::Newline"
    }
  },
-  {
-    "context": "AgentFeedbackMessageEditor > Editor",
-    "use_key_equivalents": true,
-    "bindings": {
-      "escape": "menu::Cancel",
-      "enter": "menu::Confirm",
-      "alt-enter": "editor::Newline"
-    }
-  },
  {
    "context": "ContextStrip",
    "bindings": {
-      "up": "agent::FocusUp",
-      "right": "agent::FocusRight",
-      "left": "agent::FocusLeft",
-      "down": "agent::FocusDown",
-      "backspace": "agent::RemoveFocusedContext",
-      "enter": "agent::AcceptSuggestedContext"
+      "up": "assistant2::FocusUp",
+      "right": "assistant2::FocusRight",
+      "left": "assistant2::FocusLeft",
+      "down": "assistant2::FocusDown",
+      "backspace": "assistant2::RemoveFocusedContext",
+      "enter": "assistant2::AcceptSuggestedContext"
    }
  },
  {
    "context": "ThreadHistory",
    "bindings": {
-      "backspace": "agent::RemoveSelectedThread"
+      "backspace": "assistant2::RemoveSelectedThread"
    }
  },
  {
@@ -688,7 +686,7 @@
    "bindings": {
      "ctrl-[": "assistant::CyclePreviousInlineAssist",
      "ctrl-]": "assistant::CycleNextInlineAssist",
-      "ctrl-alt-e": "agent::RemoveAllContext"
+      "ctrl-alt-e": "assistant2::RemoveAllContext"
    }
  },
  {
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -228,7 +228,7 @@
    }
  },
  {
-    "context": "Editor && !agent_diff",
+    "context": "Editor && !assistant_diff",
    "use_key_equivalents": true,
    "bindings": {
      "cmd-alt-z": "git::Restore",
@@ -238,11 +238,11 @@
    }
  },
  {
-    "context": "AgentDiff",
+    "context": "AssistantDiff",
    "use_key_equivalents": true,
    "bindings": {
-      "cmd-y": "agent::Keep",
-      "cmd-alt-z": "agent::Reject"
+      "cmd-y": "assistant2::ToggleKeep",
+      "cmd-alt-z": "assistant2::Reject"
    }
  },
  {
@@ -277,35 +277,35 @@
    }
  },
  {
-    "context": "AgentPanel",
+    "context": "AssistantPanel2",
    "use_key_equivalents": true,
    "bindings": {
-      "cmd-n": "agent::NewThread",
-      "cmd-alt-n": "agent::NewPromptEditor",
-      "cmd-shift-h": "agent::OpenHistory",
-      "cmd-alt-c": "agent::OpenConfiguration",
-      "cmd-i": "agent::ToggleProfileSelector",
+      "cmd-n": "assistant2::NewThread",
+      "cmd-alt-n": "assistant2::NewPromptEditor",
+      "cmd-shift-h": "assistant2::OpenHistory",
+      "cmd-alt-c": "assistant2::OpenConfiguration",
+      "cmd-i": "assistant2::ToggleProfileSelector",
      "cmd-alt-/": "assistant::ToggleModelSelector",
-      "cmd-shift-a": "agent::ToggleContextPicker",
-      "cmd-e": "agent::ChatMode",
-      "cmd-alt-e": "agent::RemoveAllContext"
+      "cmd-shift-a": "assistant2::ToggleContextPicker",
+      "cmd-e": "assistant2::ChatMode",
+      "cmd-alt-e": "assistant2::RemoveAllContext"
    }
  },
  {
-    "context": "AgentPanel && prompt_editor",
+    "context": "AssistantPanel2 && prompt_editor",
    "use_key_equivalents": true,
    "bindings": {
-      "cmd-n": "agent::NewPromptEditor",
-      "cmd-alt-t": "agent::NewThread"
+      "cmd-n": "assistant2::NewPromptEditor",
+      "cmd-alt-t": "assistant2::NewThread"
    }
  },
  {
    "context": "MessageEditor > Editor",
    "use_key_equivalents": true,
    "bindings": {
-      "enter": "agent::Chat",
-      "cmd-i": "agent::ToggleProfileSelector",
-      "shift-ctrl-r": "agent::OpenAgentDiff"
+      "enter": "assistant2::Chat",
+      "cmd-i": "assistant2::ToggleProfileSelector",
+      "shift-ctrl-r": "assistant2::OpenAssistantDiff"
    }
  },
  {
@@ -317,31 +317,22 @@
      "alt-enter": "editor::Newline"
    }
  },
-  {
-    "context": "AgentFeedbackMessageEditor > Editor",
-    "use_key_equivalents": true,
-    "bindings": {
-      "escape": "menu::Cancel",
-      "enter": "menu::Confirm",
-      "alt-enter": "editor::Newline"
-    }
-  },
  {
    "context": "ContextStrip",
    "use_key_equivalents": true,
    "bindings": {
-      "up": "agent::FocusUp",
-      "right": "agent::FocusRight",
-      "left": "agent::FocusLeft",
-      "down": "agent::FocusDown",
-      "backspace": "agent::RemoveFocusedContext",
-      "enter": "agent::AcceptSuggestedContext"
+      "up": "assistant2::FocusUp",
+      "right": "assistant2::FocusRight",
+      "left": "assistant2::FocusLeft",
+      "down": "assistant2::FocusDown",
+      "backspace": "assistant2::RemoveFocusedContext",
+      "enter": "assistant2::AcceptSuggestedContext"
    }
  },
  {
-    "context": "ThreadHistory > Editor",
+    "context": "ThreadHistory",
    "bindings": {
-      "shift-backspace": "agent::RemoveSelectedThread"
+      "backspace": "assistant2::RemoveSelectedThread"
    }
  },
  {
@@ -713,13 +704,21 @@
      "ctrl-:": "editor::ToggleInlayHints"
    }
  },
+  {
+    "context": "ProposedChangesEditor",
+    "use_key_equivalents": true,
+    "bindings": {
+      "cmd-shift-y": "editor::ApplyDiffHunk",
+      "cmd-shift-a": "editor::ApplyAllDiffHunks"
+    }
+  },
  {
    "context": "PromptEditor",
    "use_key_equivalents": true,
    "bindings": {
-      "cmd-shift-a": "agent::ToggleContextPicker",
+      "cmd-shift-a": "assistant2::ToggleContextPicker",
      "cmd-alt-/": "assistant::ToggleModelSelector",
-      "cmd-alt-e": "agent::RemoveAllContext",
+      "cmd-alt-e": "assistant2::RemoveAllContext",
      "ctrl-[": "assistant::CyclePreviousInlineAssist",
      "ctrl-]": "assistant::CycleNextInlineAssist"
    }
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -227,8 +227,6 @@
      "g u": "vim::PushLowercase",
      "g shift-u": "vim::PushUppercase",
      "g ~": "vim::PushOppositeCase",
-      "g ?": "vim::PushRot13",
-      // "g ?": "vim::PushRot47",
      "\"": "vim::PushRegister",
      "g w": "vim::PushRewrap",
      "g q": "vim::PushRewrap",
@@ -300,8 +298,6 @@
      "g r": ["vim::Paste", { "preserve_clipboard": true }],
      "g c": "vim::ToggleComments",
      "g q": "vim::Rewrap",
-      "g ?": "vim::ConvertToRot13",
-      // "g ?": "vim::ConvertToRot47",
      "\"": "vim::PushRegister",
      // tree-sitter related commands
      "[ x": "editor::SelectLargerSyntaxNode",
@@ -343,6 +339,10 @@
      "w": "vim::NextWordStart",
      "e": "vim::NextWordEnd",
      "b": "vim::PreviousWordStart",
+      "x": "vim::CurrentLine",
+      "X": "vim::CurrentLine",
+      "y": "vim::HelixYank",
+      "p": "vim::HelixPaste",

      "h": "vim::Left",
      "j": "vim::Down",
@@ -481,13 +481,6 @@
      "~": "vim::CurrentLine"
    }
  },
-  {
-    "context": "vim_operator == g?",
-    "bindings": {
-      "g ?": "vim::CurrentLine",
-      "?": "vim::CurrentLine"
-    }
-  },
  {
    "context": "vim_operator == gq",
    "bindings": {
--- a/assets/prompts/assistant_system_prompt.hbs
+++ b/assets/prompts/assistant_system_prompt.hbs
@@ -8,31 +8,10 @@ It will be up to you to decide which of these you are doing based on what the us
 You should only perform actions that modify the user's system if explicitly requested by the user:
 - If the user asks a question about how to accomplish a task, provide guidance or information, and use read-only tools (e.g., search) to assist. You may suggest potential actions, but do not directly modify the user’s system without explicit instruction.
 - If the user clearly requests that you perform an action, carry out the action directly without explaining why you are doing so.
-
-Editing code:
- Make sure to take previous edits into account.
- The edits you perform might lead to errors or warnings. At the end of your changes, check whether you introduced any problems, and fix them before providing a summary of the changes you made.
- You may only attempt to fix these up to 3 times. If you have tried 3 times to fix them, and there are still problems remaining, you must not continue trying to fix them, and must instead tell the user that there are problems remaining - and ask if the user would like you to attempt to solve them further.
+- The editing actions you perform might produce errors or warnings. At the end of your changes, check whether you introduced any problems, and fix them before providing a summary of the changes you made. You may only attempt to fix these up to 3 times. If you have tried 3 times to fix them, and there are still problems remaining, you must not continue trying to fix them, and must instead tell the user that there are problems remaining - and ask if the user would like you to attempt to solve them further.
 - Do not fix errors unrelated to your changes unless the user explicitly asks you to do so.
- Prefer to move files over recreating them. The move can be followed by minor edits if required.
- If you seem to be stuck, never go back and "simplify the implementation" by deleting the parts of the implementation you're stuck on and replacing them with comments. If you ever feel the urge to do this, instead immediately stop whatever you're doing (even if the code is in a broken state), report that you are stuck, explain what you're stuck on, and ask the user how to proceed.

-Tool use:
- Make sure to adhere to the tools schema.
- Provide every required argument.
- DO NOT use tools to access items that are already available in the context section.
- Use only the tools that are currently available.
- DO NOT use a tool that is not available just because it appears in the conversation. This means the user turned it off.
-
-Responding:
- Be concise and direct in your responses.
- Never apologize or thank the user.
- Don't comment that you have just realized or understood something.
- When you are going to make a tool call, tersely explain your reasoning for choosing to use that tool, with no flourishes or commentary beyond that information.
-    For example, rather than saying "You're absolutely right! Thank you for providing that context. Now I understand that we're missing a dependency, and I need to add it:" say "I'll add that missing dependency:" instead.
- Also, don't restate what a tool call is about to do (or just did).
-    For example, don't say "Now I'm going to check diagnostics to see if there are any warnings or errors," followed by running a tool which checks diagnostics and reports warnings or errors; instead, just request the tool call without saying anything.
- All tool results are provided to you automatically, so DO NOT thank the user when this happens.
+Be concise and direct in your responses. Never apologize or thank the user. Don't comment that you have just realized or understood something. When you are going to make a tool call, tersely explain your reasoning for choosing to use that tool, with no flourishes or commentary beyond that information. For example, rather than saying "You're absolutely right! Thank you for providing that context. Now I understand that we're missing a dependency, and I need to add it:" say "I'll add that missing dependency:" instead. Also, don't restate what a tool call is about to do (or just did). For example, don't say "Now I'm going to check diagnostics to see if there are any warnings or errors," followed by running a tool which checks diagnostics and reports warnings or errors; instead, just request the tool call without saying anything.

 The user has opened a project that contains the following root directories/files. Whenever you specify a path in the project, it must be a relative path which begins with one of these root directories/files:

--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -633,45 +633,41 @@
      // The model to use.
      "model": "claude-3-5-sonnet-latest"
    },
-    // When enabled, the agent can run potentially destructive actions without asking for your confirmation.
-    "always_allow_tool_actions": false,
    "default_profile": "write",
    "profiles": {
      "ask": {
        "name": "Ask",
-        // We don't know which of the context server tools are safe for the "Ask" profile, so we don't enable them by default.
-        // "enable_all_context_servers": true,
        "tools": {
          "diagnostics": true,
          "fetch": true,
-          "list_directory": false,
+          "list-directory": true,
          "now": true,
-          "path_search": true,
-          "read_file": true,
-          "regex_search": true,
+          "path-search": true,
+          "read-file": true,
+          "regex-search": true,
          "thinking": true
        }
      },
      "write": {
        "name": "Write",
-        "enable_all_context_servers": true,
        "tools": {
          "bash": true,
-          "batch_tool": true,
-          "code_symbols": true,
-          "copy_path": false,
-          "create_file": true,
-          "delete_path": false,
+          "batch-tool": true,
+          "code-symbols": true,
+          "copy-path": true,
+          "create-file": true,
+          "delete-path": true,
          "diagnostics": true,
-          "find_replace_file": true,
+          "find-replace-file": true,
+          "edit-files": false,
          "fetch": true,
-          "list_directory": false,
-          "move_path": false,
+          "list-directory": true,
+          "move-path": true,
          "now": true,
-          "path_search": true,
-          "read_file": true,
-          "regex_search": true,
-          "symbol_info": true,
+          "path-search": true,
+          "read-file": true,
+          "regex-search": true,
+          "symbol-info": true,
          "thinking": true
        }
      }
--- a/crates/activity_indicator/Cargo.toml
+++ b/crates/activity_indicator/Cargo.toml
@@ -25,7 +25,6 @@ smallvec.workspace = true
 ui.workspace = true
 util.workspace = true
 workspace.workspace = true
-workspace-hack.workspace = true

 [dev-dependencies]
 editor = { workspace = true, features = ["test-support"] }
--- a/crates/activity_indicator/src/activity_indicator.rs
+++ b/crates/activity_indicator/src/activity_indicator.rs
@@ -10,10 +10,10 @@ use gpui::{
 use language::{BinaryStatus, LanguageRegistry, LanguageServerId};
 use project::{
    EnvironmentErrorMessage, LanguageServerProgress, LspStoreEvent, Project,
-    ProjectEnvironmentEvent,
+    ProjectEnvironmentEvent, WorktreeId,
 };
 use smallvec::SmallVec;
-use std::{cmp::Reverse, fmt::Write, path::Path, sync::Arc, time::Duration};
+use std::{cmp::Reverse, fmt::Write, sync::Arc, time::Duration};
 use ui::{ButtonLike, ContextMenu, PopoverMenu, PopoverMenuHandle, Tooltip, prelude::*};
 use util::truncate_and_trailoff;
 use workspace::{StatusItemView, Workspace, item::ItemHandle};
@@ -218,14 +218,13 @@ impl ActivityIndicator {
    fn pending_environment_errors<'a>(
        &'a self,
        cx: &'a App,
-    ) -> impl Iterator<Item = (&'a Arc<Path>, &'a EnvironmentErrorMessage)> {
+    ) -> impl Iterator<Item = (&'a WorktreeId, &'a EnvironmentErrorMessage)> {
        self.project.read(cx).shell_environment_errors(cx)
    }

    fn content_to_render(&mut self, cx: &mut Context<Self>) -> Option<Content> {
        // Show if any direnv calls failed
-        if let Some((abs_path, error)) = self.pending_environment_errors(cx).next() {
-            let abs_path = abs_path.clone();
+        if let Some((&worktree_id, error)) = self.pending_environment_errors(cx).next() {
            return Some(Content {
                icon: Some(
                    Icon::new(IconName::Warning)
@@ -235,7 +234,7 @@ impl ActivityIndicator {
                message: error.0.clone(),
                on_click: Some(Arc::new(move |this, window, cx| {
                    this.project.update(cx, |project, cx| {
-                        project.remove_environment_error(&abs_path, cx);
+                        project.remove_environment_error(worktree_id, cx);
                    });
                    window.dispatch_action(Box::new(workspace::OpenLog), cx);
                })),
--- a/crates/agent/src/thread_history.rs
+++ b/crates/agent/src/thread_history.rs
@@ -1,589 +0,0 @@
-use std::sync::Arc;
-
-use assistant_context_editor::SavedContextMetadata;
-use editor::{Editor, EditorEvent};
-use fuzzy::{StringMatch, StringMatchCandidate};
-use gpui::{
-    App, Entity, FocusHandle, Focusable, ScrollStrategy, Task, UniformListScrollHandle, WeakEntity,
-    Window, uniform_list,
-};
-use time::{OffsetDateTime, UtcOffset};
-use ui::{HighlightedLabel, IconButtonShape, ListItem, ListItemSpacing, Tooltip, prelude::*};
-use util::ResultExt;
-
-use crate::history_store::{HistoryEntry, HistoryStore};
-use crate::thread_store::SerializedThreadMetadata;
-use crate::{AssistantPanel, RemoveSelectedThread};
-
-pub struct ThreadHistory {
-    assistant_panel: WeakEntity<AssistantPanel>,
-    history_store: Entity<HistoryStore>,
-    scroll_handle: UniformListScrollHandle,
-    selected_index: usize,
-    search_query: SharedString,
-    search_editor: Entity<Editor>,
-    all_entries: Arc<Vec<HistoryEntry>>,
-    matches: Vec<StringMatch>,
-    _subscriptions: Vec<gpui::Subscription>,
-    _search_task: Option<Task<()>>,
-}
-
-impl ThreadHistory {
-    pub(crate) fn new(
-        assistant_panel: WeakEntity<AssistantPanel>,
-        history_store: Entity<HistoryStore>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Self {
-        let search_editor = cx.new(|cx| {
-            let mut editor = Editor::single_line(window, cx);
-            editor.set_placeholder_text("Search threads...", cx);
-            editor
-        });
-
-        let search_editor_subscription =
-            cx.subscribe(&search_editor, |this, search_editor, event, cx| {
-                if let EditorEvent::BufferEdited = event {
-                    let query = search_editor.read(cx).text(cx);
-                    this.search_query = query.into();
-                    this.update_search(cx);
-                }
-            });
-
-        let entries: Arc<Vec<_>> = history_store
-            .update(cx, |store, cx| store.entries(cx))
-            .into();
-
-        let history_store_subscription = cx.observe(&history_store, |this, _, cx| {
-            this.update_all_entries(cx);
-        });
-
-        Self {
-            assistant_panel,
-            history_store,
-            scroll_handle: UniformListScrollHandle::default(),
-            selected_index: 0,
-            search_query: SharedString::new_static(""),
-            all_entries: entries,
-            matches: Vec::new(),
-            search_editor,
-            _subscriptions: vec![search_editor_subscription, history_store_subscription],
-            _search_task: None,
-        }
-    }
-
-    fn update_all_entries(&mut self, cx: &mut Context<Self>) {
-        self.all_entries = self
-            .history_store
-            .update(cx, |store, cx| store.entries(cx))
-            .into();
-        self.matches.clear();
-        self.update_search(cx);
-    }
-
-    fn update_search(&mut self, cx: &mut Context<Self>) {
-        self._search_task.take();
-
-        if self.has_search_query() {
-            self.perform_search(cx);
-        } else {
-            self.matches.clear();
-            self.set_selected_index(0, cx);
-            cx.notify();
-        }
-    }
-
-    fn perform_search(&mut self, cx: &mut Context<Self>) {
-        let query = self.search_query.clone();
-        let all_entries = self.all_entries.clone();
-
-        let task = cx.spawn(async move |this, cx| {
-            let executor = cx.background_executor().clone();
-
-            let matches = cx
-                .background_spawn(async move {
-                    let mut candidates = Vec::with_capacity(all_entries.len());
-
-                    for (idx, entry) in all_entries.iter().enumerate() {
-                        match entry {
-                            HistoryEntry::Thread(thread) => {
-                                candidates.push(StringMatchCandidate::new(idx, &thread.summary));
-                            }
-                            HistoryEntry::Context(context) => {
-                                candidates.push(StringMatchCandidate::new(idx, &context.title));
-                            }
-                        }
-                    }
-
-                    const MAX_MATCHES: usize = 100;
-
-                    fuzzy::match_strings(
-                        &candidates,
-                        &query,
-                        false,
-                        MAX_MATCHES,
-                        &Default::default(),
-                        executor,
-                    )
-                    .await
-                })
-                .await;
-
-            this.update(cx, |this, cx| {
-                this.matches = matches;
-                this.set_selected_index(0, cx);
-                cx.notify();
-            })
-            .log_err();
-        });
-
-        self._search_task = Some(task);
-    }
-
-    fn has_search_query(&self) -> bool {
-        !self.search_query.is_empty()
-    }
-
-    fn matched_count(&self) -> usize {
-        if self.has_search_query() {
-            self.matches.len()
-        } else {
-            self.all_entries.len()
-        }
-    }
-
-    fn get_match(&self, ix: usize) -> Option<&HistoryEntry> {
-        if self.has_search_query() {
-            self.matches
-                .get(ix)
-                .and_then(|m| self.all_entries.get(m.candidate_id))
-        } else {
-            self.all_entries.get(ix)
-        }
-    }
-
-    pub fn select_previous(
-        &mut self,
-        _: &menu::SelectPrevious,
-        _window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        let count = self.matched_count();
-        if count > 0 {
-            if self.selected_index == 0 {
-                self.set_selected_index(count - 1, cx);
-            } else {
-                self.set_selected_index(self.selected_index - 1, cx);
-            }
-        }
-    }
-
-    pub fn select_next(
-        &mut self,
-        _: &menu::SelectNext,
-        _window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        let count = self.matched_count();
-        if count > 0 {
-            if self.selected_index == count - 1 {
-                self.set_selected_index(0, cx);
-            } else {
-                self.set_selected_index(self.selected_index + 1, cx);
-            }
-        }
-    }
-
-    fn select_first(
-        &mut self,
-        _: &menu::SelectFirst,
-        _window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        let count = self.matched_count();
-        if count > 0 {
-            self.set_selected_index(0, cx);
-        }
-    }
-
-    fn select_last(&mut self, _: &menu::SelectLast, _window: &mut Window, cx: &mut Context<Self>) {
-        let count = self.matched_count();
-        if count > 0 {
-            self.set_selected_index(count - 1, cx);
-        }
-    }
-
-    fn set_selected_index(&mut self, index: usize, cx: &mut Context<Self>) {
-        self.selected_index = index;
-        self.scroll_handle
-            .scroll_to_item(index, ScrollStrategy::Top);
-        cx.notify();
-    }
-
-    fn confirm(&mut self, _: &menu::Confirm, window: &mut Window, cx: &mut Context<Self>) {
-        if let Some(entry) = self.get_match(self.selected_index) {
-            let task_result = match entry {
-                HistoryEntry::Thread(thread) => self
-                    .assistant_panel
-                    .update(cx, move |this, cx| this.open_thread(&thread.id, window, cx)),
-                HistoryEntry::Context(context) => {
-                    self.assistant_panel.update(cx, move |this, cx| {
-                        this.open_saved_prompt_editor(context.path.clone(), window, cx)
-                    })
-                }
-            };
-
-            if let Some(task) = task_result.log_err() {
-                task.detach_and_log_err(cx);
-            };
-
-            cx.notify();
-        }
-    }
-
-    fn remove_selected_thread(
-        &mut self,
-        _: &RemoveSelectedThread,
-        _window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        if let Some(entry) = self.get_match(self.selected_index) {
-            let task_result = match entry {
-                HistoryEntry::Thread(thread) => self
-                    .assistant_panel
-                    .update(cx, |this, cx| this.delete_thread(&thread.id, cx)),
-                HistoryEntry::Context(context) => self
-                    .assistant_panel
-                    .update(cx, |this, cx| this.delete_context(context.path.clone(), cx)),
-            };
-
-            if let Some(task) = task_result.log_err() {
-                task.detach_and_log_err(cx);
-            };
-
-            cx.notify();
-        }
-    }
-}
-
-impl Focusable for ThreadHistory {
-    fn focus_handle(&self, cx: &App) -> FocusHandle {
-        self.search_editor.focus_handle(cx)
-    }
-}
-
-impl Render for ThreadHistory {
-    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let selected_index = self.selected_index;
-
-        v_flex()
-            .key_context("ThreadHistory")
-            .size_full()
-            .on_action(cx.listener(Self::select_previous))
-            .on_action(cx.listener(Self::select_next))
-            .on_action(cx.listener(Self::select_first))
-            .on_action(cx.listener(Self::select_last))
-            .on_action(cx.listener(Self::confirm))
-            .on_action(cx.listener(Self::remove_selected_thread))
-            .when(!self.all_entries.is_empty(), |parent| {
-                parent.child(
-                    h_flex()
-                        .h(px(41.)) // Match the toolbar perfectly
-                        .w_full()
-                        .py_1()
-                        .px_2()
-                        .gap_2()
-                        .justify_between()
-                        .border_b_1()
-                        .border_color(cx.theme().colors().border)
-                        .child(
-                            Icon::new(IconName::MagnifyingGlass)
-                                .color(Color::Muted)
-                                .size(IconSize::Small),
-                        )
-                        .child(self.search_editor.clone()),
-                )
-            })
-            .child({
-                let view = v_flex().overflow_hidden().flex_grow();
-
-                if self.all_entries.is_empty() {
-                    view.justify_center()
-                        .child(
-                            h_flex().w_full().justify_center().child(
-                                Label::new("You don't have any past threads yet.")
-                                    .size(LabelSize::Small),
-                            ),
-                        )
-                } else if self.has_search_query() && self.matches.is_empty() {
-                    view.justify_center().child(
-                        h_flex().w_full().justify_center().child(
-                            Label::new("No threads match your search.").size(LabelSize::Small),
-                        ),
-                    )
-                } else {
-                    view.p_1().child(
-                        uniform_list(
-                            cx.entity().clone(),
-                            "thread-history",
-                            self.matched_count(),
-                            move |history, range, _window, _cx| {
-                                let range_start = range.start;
-                                let assistant_panel = history.assistant_panel.clone();
-
-                                let render_item = |index: usize,
-                                                   entry: &HistoryEntry,
-                                                   highlight_positions: Vec<usize>|
-                                 -> Div {
-                                    h_flex().w_full().pb_1().child(match entry {
-                                        HistoryEntry::Thread(thread) => PastThread::new(
-                                            thread.clone(),
-                                            assistant_panel.clone(),
-                                            selected_index == index + range_start,
-                                            highlight_positions,
-                                        )
-                                        .into_any_element(),
-                                        HistoryEntry::Context(context) => PastContext::new(
-                                            context.clone(),
-                                            assistant_panel.clone(),
-                                            selected_index == index + range_start,
-                                            highlight_positions,
-                                        )
-                                        .into_any_element(),
-                                    })
-                                };
-
-                                if history.has_search_query() {
-                                    history.matches[range]
-                                        .iter()
-                                        .enumerate()
-                                        .filter_map(|(index, m)| {
-                                            history.all_entries.get(m.candidate_id).map(|entry| {
-                                                render_item(index, entry, m.positions.clone())
-                                            })
-                                        })
-                                        .collect()
-                                } else {
-                                    history.all_entries[range]
-                                        .iter()
-                                        .enumerate()
-                                        .map(|(index, entry)| render_item(index, entry, vec![]))
-                                        .collect()
-                                }
-                            },
-                        )
-                        .track_scroll(self.scroll_handle.clone())
-                        .flex_grow(),
-                    )
-                }
-            })
-    }
-}
-
-#[derive(IntoElement)]
-pub struct PastThread {
-    thread: SerializedThreadMetadata,
-    assistant_panel: WeakEntity<AssistantPanel>,
-    selected: bool,
-    highlight_positions: Vec<usize>,
-}
-
-impl PastThread {
-    pub fn new(
-        thread: SerializedThreadMetadata,
-        assistant_panel: WeakEntity<AssistantPanel>,
-        selected: bool,
-        highlight_positions: Vec<usize>,
-    ) -> Self {
-        Self {
-            thread,
-            assistant_panel,
-            selected,
-            highlight_positions,
-        }
-    }
-}
-
-impl RenderOnce for PastThread {
-    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
-        let summary = self.thread.summary;
-
-        let thread_timestamp = time_format::format_localized_timestamp(
-            OffsetDateTime::from_unix_timestamp(self.thread.updated_at.timestamp()).unwrap(),
-            OffsetDateTime::now_utc(),
-            self.assistant_panel
-                .update(cx, |this, _cx| this.local_timezone())
-                .unwrap_or(UtcOffset::UTC),
-            time_format::TimestampFormat::EnhancedAbsolute,
-        );
-
-        ListItem::new(SharedString::from(self.thread.id.to_string()))
-            .rounded()
-            .toggle_state(self.selected)
-            .spacing(ListItemSpacing::Sparse)
-            .start_slot(
-                div().max_w_4_5().child(
-                    HighlightedLabel::new(summary, self.highlight_positions)
-                        .size(LabelSize::Small)
-                        .truncate(),
-                ),
-            )
-            .end_slot(
-                h_flex()
-                    .gap_1p5()
-                    .child(
-                        Label::new("Thread")
-                            .color(Color::Muted)
-                            .size(LabelSize::XSmall),
-                    )
-                    .child(
-                        div()
-                            .size(px(3.))
-                            .rounded_full()
-                            .bg(cx.theme().colors().text_disabled),
-                    )
-                    .child(
-                        Label::new(thread_timestamp)
-                            .color(Color::Muted)
-                            .size(LabelSize::XSmall),
-                    )
-                    .child(
-                        IconButton::new("delete", IconName::TrashAlt)
-                            .shape(IconButtonShape::Square)
-                            .icon_size(IconSize::XSmall)
-                            .tooltip(move |window, cx| {
-                                Tooltip::for_action(
-                                    "Delete Thread",
-                                    &RemoveSelectedThread,
-                                    window,
-                                    cx,
-                                )
-                            })
-                            .on_click({
-                                let assistant_panel = self.assistant_panel.clone();
-                                let id = self.thread.id.clone();
-                                move |_event, _window, cx| {
-                                    assistant_panel
-                                        .update(cx, |this, cx| {
-                                            this.delete_thread(&id, cx).detach_and_log_err(cx);
-                                        })
-                                        .ok();
-                                }
-                            }),
-                    ),
-            )
-            .on_click({
-                let assistant_panel = self.assistant_panel.clone();
-                let id = self.thread.id.clone();
-                move |_event, window, cx| {
-                    assistant_panel
-                        .update(cx, |this, cx| {
-                            this.open_thread(&id, window, cx).detach_and_log_err(cx);
-                        })
-                        .ok();
-                }
-            })
-    }
-}
-
-#[derive(IntoElement)]
-pub struct PastContext {
-    context: SavedContextMetadata,
-    assistant_panel: WeakEntity<AssistantPanel>,
-    selected: bool,
-    highlight_positions: Vec<usize>,
-}
-
-impl PastContext {
-    pub fn new(
-        context: SavedContextMetadata,
-        assistant_panel: WeakEntity<AssistantPanel>,
-        selected: bool,
-        highlight_positions: Vec<usize>,
-    ) -> Self {
-        Self {
-            context,
-            assistant_panel,
-            selected,
-            highlight_positions,
-        }
-    }
-}
-
-impl RenderOnce for PastContext {
-    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
-        let summary = self.context.title;
-        let context_timestamp = time_format::format_localized_timestamp(
-            OffsetDateTime::from_unix_timestamp(self.context.mtime.timestamp()).unwrap(),
-            OffsetDateTime::now_utc(),
-            self.assistant_panel
-                .update(cx, |this, _cx| this.local_timezone())
-                .unwrap_or(UtcOffset::UTC),
-            time_format::TimestampFormat::EnhancedAbsolute,
-        );
-
-        ListItem::new(SharedString::from(
-            self.context.path.to_string_lossy().to_string(),
-        ))
-        .rounded()
-        .toggle_state(self.selected)
-        .spacing(ListItemSpacing::Sparse)
-        .start_slot(
-            div().max_w_4_5().child(
-                HighlightedLabel::new(summary, self.highlight_positions)
-                    .size(LabelSize::Small)
-                    .truncate(),
-            ),
-        )
-        .end_slot(
-            h_flex()
-                .gap_1p5()
-                .child(
-                    Label::new("Prompt Editor")
-                        .color(Color::Muted)
-                        .size(LabelSize::XSmall),
-                )
-                .child(
-                    div()
-                        .size(px(3.))
-                        .rounded_full()
-                        .bg(cx.theme().colors().text_disabled),
-                )
-                .child(
-                    Label::new(context_timestamp)
-                        .color(Color::Muted)
-                        .size(LabelSize::XSmall),
-                )
-                .child(
-                    IconButton::new("delete", IconName::TrashAlt)
-                        .shape(IconButtonShape::Square)
-                        .icon_size(IconSize::XSmall)
-                        .tooltip(Tooltip::text("Delete Prompt Editor"))
-                        .on_click({
-                            let assistant_panel = self.assistant_panel.clone();
-                            let path = self.context.path.clone();
-                            move |_event, _window, cx| {
-                                assistant_panel
-                                    .update(cx, |this, cx| {
-                                        this.delete_context(path.clone(), cx)
-                                            .detach_and_log_err(cx);
-                                    })
-                                    .ok();
-                            }
-                        }),
-                ),
-        )
-        .on_click({
-            let assistant_panel = self.assistant_panel.clone();
-            let path = self.context.path.clone();
-            move |_event, window, cx| {
-                assistant_panel
-                    .update(cx, |this, cx| {
-                        this.open_saved_prompt_editor(path.clone(), window, cx)
-                            .detach_and_log_err(cx);
-                    })
-                    .ok();
-            }
-        })
-    }
-}
--- a/crates/anthropic/Cargo.toml
+++ b/crates/anthropic/Cargo.toml
@@ -26,4 +26,3 @@ serde_json.workspace = true
 strum.workspace = true
 thiserror.workspace = true
 util.workspace = true
-workspace-hack.workspace = true
--- a/crates/anthropic/src/anthropic.rs
+++ b/crates/anthropic/src/anthropic.rs
@@ -1,10 +1,10 @@
 mod supported_countries;

-use std::str::FromStr;
+use std::{pin::Pin, str::FromStr};

 use anyhow::{Context as _, Result, anyhow};
 use chrono::{DateTime, Utc};
-use futures::{AsyncBufReadExt, AsyncReadExt, StreamExt, io::BufReader, stream::BoxStream};
+use futures::{AsyncBufReadExt, AsyncReadExt, Stream, StreamExt, io::BufReader, stream::BoxStream};
 use http_client::http::{HeaderMap, HeaderValue};
 use http_client::{AsyncBody, HttpClient, Method, Request as HttpRequest};
 use serde::{Deserialize, Serialize};
@@ -220,23 +220,16 @@ impl Model {
            .map(|header| header.to_string())
            .collect::<Vec<_>>();

-        match self {
-            Self::Claude3_7Sonnet | Self::Claude3_7SonnetThinking => {
-                // Try beta token-efficient tool use (supported in Claude 3.7 Sonnet only)
-                // https://docs.anthropic.com/en/docs/build-with-claude/tool-use/token-efficient-tool-use
-                headers.push("token-efficient-tools-2025-02-19".to_string());
-            }
-            Self::Custom {
-                extra_beta_headers, ..
-            } => {
-                headers.extend(
-                    extra_beta_headers
-                        .iter()
-                        .filter(|header| !header.trim().is_empty())
-                        .cloned(),
-                );
-            }
-            _ => {}
+        if let Self::Custom {
+            extra_beta_headers, ..
+        } = self
+        {
+            headers.extend(
+                extra_beta_headers
+                    .iter()
+                    .filter(|header| !header.trim().is_empty())
+                    .cloned(),
+            );
        }

        headers.join(",")
@@ -444,6 +437,50 @@ pub async fn stream_completion_with_rate_limit_info(
    }
 }

+pub async fn extract_tool_args_from_events(
+    tool_name: String,
+    mut events: Pin<Box<dyn Send + Stream<Item = Result<Event>>>>,
+) -> Result<impl Send + Stream<Item = Result<String>>> {
+    let mut tool_use_index = None;
+    while let Some(event) = events.next().await {
+        if let Event::ContentBlockStart {
+            index,
+            content_block: ResponseContent::ToolUse { name, .. },
+        } = event?
+        {
+            if name == tool_name {
+                tool_use_index = Some(index);
+                break;
+            }
+        }
+    }
+
+    let Some(tool_use_index) = tool_use_index else {
+        return Err(anyhow!("tool not used"));
+    };
+
+    Ok(events.filter_map(move |event| {
+        let result = match event {
+            Err(error) => Some(Err(error)),
+            Ok(Event::ContentBlockDelta { index, delta }) => match delta {
+                ContentDelta::TextDelta { .. } => None,
+                ContentDelta::ThinkingDelta { .. } => None,
+                ContentDelta::SignatureDelta { .. } => None,
+                ContentDelta::InputJsonDelta { partial_json } => {
+                    if index == tool_use_index {
+                        Some(Ok(partial_json))
+                    } else {
+                        None
+                    }
+                }
+            },
+            _ => None,
+        };
+
+        async move { result }
+    }))
+}
+
 #[derive(Debug, Serialize, Deserialize, Copy, Clone)]
 #[serde(rename_all = "lowercase")]
 pub enum CacheControlType {
--- a/crates/askpass/Cargo.toml
+++ b/crates/askpass/Cargo.toml
@@ -19,4 +19,3 @@ smol.workspace = true
 tempfile.workspace = true
 util.workspace = true
 which.workspace = true
-workspace-hack.workspace = true
--- a/crates/assets/Cargo.toml
+++ b/crates/assets/Cargo.toml
@@ -15,4 +15,3 @@ workspace = true
 anyhow.workspace = true
 gpui.workspace = true
 rust-embed.workspace = true
-workspace-hack.workspace = true
--- a/crates/assistant/Cargo.toml
+++ b/crates/assistant/Cargo.toml
@@ -69,7 +69,6 @@ ui.workspace = true
 util.workspace = true
 workspace.workspace = true
 zed_actions.workspace = true
-workspace-hack.workspace = true

 [dev-dependencies]
 ctor.workspace = true
--- a/crates/assistant/src/assistant.rs
+++ b/crates/assistant/src/assistant.rs
@@ -161,38 +161,12 @@ fn init_language_model_settings(cx: &mut App) {

 fn update_active_language_model_from_settings(cx: &mut App) {
    let settings = AssistantSettings::get_global(cx);
-    // Default model - used as fallback
    let active_model_provider_name =
        LanguageModelProviderId::from(settings.default_model.provider.clone());
    let active_model_id = LanguageModelId::from(settings.default_model.model.clone());
-
-    // Inline assistant model
-    let inline_assistant_model = settings
-        .inline_assistant_model
-        .as_ref()
-        .unwrap_or(&settings.default_model);
-    let inline_assistant_provider_name =
-        LanguageModelProviderId::from(inline_assistant_model.provider.clone());
-    let inline_assistant_model_id = LanguageModelId::from(inline_assistant_model.model.clone());
-
-    // Commit message model
-    let commit_message_model = settings
-        .commit_message_model
-        .as_ref()
-        .unwrap_or(&settings.default_model);
-    let commit_message_provider_name =
-        LanguageModelProviderId::from(commit_message_model.provider.clone());
-    let commit_message_model_id = LanguageModelId::from(commit_message_model.model.clone());
-
-    // Thread summary model
-    let thread_summary_model = settings
-        .thread_summary_model
-        .as_ref()
-        .unwrap_or(&settings.default_model);
-    let thread_summary_provider_name =
-        LanguageModelProviderId::from(thread_summary_model.provider.clone());
-    let thread_summary_model_id = LanguageModelId::from(thread_summary_model.model.clone());
-
+    let editor_provider_name =
+        LanguageModelProviderId::from(settings.editor_model.provider.clone());
+    let editor_model_id = LanguageModelId::from(settings.editor_model.model.clone());
    let inline_alternatives = settings
        .inline_alternatives
        .iter()
@@ -203,29 +177,9 @@ fn update_active_language_model_from_settings(cx: &mut App) {
            )
        })
        .collect::<Vec<_>>();
-
    LanguageModelRegistry::global(cx).update(cx, |registry, cx| {
-        // Set the default model
-        registry.select_default_model(&active_model_provider_name, &active_model_id, cx);
-
-        // Set the specific models
-        registry.select_inline_assistant_model(
-            &inline_assistant_provider_name,
-            &inline_assistant_model_id,
-            cx,
-        );
-        registry.select_commit_message_model(
-            &commit_message_provider_name,
-            &commit_message_model_id,
-            cx,
-        );
-        registry.select_thread_summary_model(
-            &thread_summary_provider_name,
-            &thread_summary_model_id,
-            cx,
-        );
-
-        // Set the alternatives
+        registry.select_active_model(&active_model_provider_name, &active_model_id, cx);
+        registry.select_editor_model(&editor_provider_name, &editor_model_id, cx);
        registry.select_inline_alternative_models(inline_alternatives, cx);
    });
 }
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -22,8 +22,7 @@ use gpui::{
 };
 use language::LanguageRegistry;
 use language_model::{
-    AuthenticateError, ConfiguredModel, LanguageModelProviderId, LanguageModelRegistry,
-    ZED_CLOUD_PROVIDER_ID,
+    AuthenticateError, LanguageModelProviderId, LanguageModelRegistry, ZED_CLOUD_PROVIDER_ID,
 };
 use project::Project;
 use prompt_library::{PromptLibrary, open_prompt_library};
@@ -37,11 +36,11 @@ use ui::{ContextMenu, PopoverMenu, Tooltip, prelude::*};
 use util::{ResultExt, maybe};
 use workspace::DraggedTab;
 use workspace::{
-    DraggedSelection, Pane, ToggleZoom, Workspace,
+    DraggedSelection, Pane, ShowConfiguration, ToggleZoom, Workspace,
    dock::{DockPosition, Panel, PanelEvent},
    pane,
 };
-use zed_actions::assistant::{InlineAssist, OpenPromptLibrary, ShowConfiguration, ToggleFocus};
+use zed_actions::assistant::{InlineAssist, OpenPromptLibrary, ToggleFocus};

 pub fn init(cx: &mut App) {
    workspace::FollowableViewRegistry::register::<ContextEditor>(cx);
@@ -54,15 +53,7 @@ pub fn init(cx: &mut App) {
                .register_action(ContextEditor::insert_dragged_files)
                .register_action(AssistantPanel::show_configuration)
                .register_action(AssistantPanel::create_new_context)
-                .register_action(AssistantPanel::restart_context_servers)
-                .register_action(|workspace, _: &OpenPromptLibrary, window, cx| {
-                    if let Some(panel) = workspace.panel::<AssistantPanel>(cx) {
-                        workspace.focus_panel::<AssistantPanel>(window, cx);
-                        panel.update(cx, |panel, cx| {
-                            panel.deploy_prompt_library(&OpenPromptLibrary, window, cx)
-                        });
-                    }
-                });
+                .register_action(AssistantPanel::restart_context_servers);
        },
    )
    .detach();
@@ -307,10 +298,8 @@ impl AssistantPanel {
                &LanguageModelRegistry::global(cx),
                window,
                |this, _, event: &language_model::Event, window, cx| match event {
-                    language_model::Event::DefaultModelChanged
-                    | language_model::Event::InlineAssistantModelChanged
-                    | language_model::Event::CommitMessageModelChanged
-                    | language_model::Event::ThreadSummaryModelChanged => {
+                    language_model::Event::ActiveModelChanged
+                    | language_model::Event::EditorModelChanged => {
                        this.completion_provider_changed(window, cx);
                    }
                    language_model::Event::ProviderStateChanged => {
@@ -479,12 +468,12 @@ impl AssistantPanel {
    }

    fn update_zed_ai_notice_visibility(&mut self, client_status: Status, cx: &mut Context<Self>) {
-        let model = LanguageModelRegistry::read_global(cx).default_model();
+        let active_provider = LanguageModelRegistry::read_global(cx).active_provider();

        // If we're signed out and don't have a provider configured, or we're signed-out AND Zed.dev is
        // the provider, we want to show a nudge to sign in.
        let show_zed_ai_notice = client_status.is_signed_out()
-            && model.map_or(true, |model| model.provider.id().0 == ZED_CLOUD_PROVIDER_ID);
+            && active_provider.map_or(true, |provider| provider.id().0 == ZED_CLOUD_PROVIDER_ID);

        self.show_zed_ai_notice = show_zed_ai_notice;
        cx.notify();
@@ -552,8 +541,8 @@ impl AssistantPanel {
        }

        let Some(new_provider_id) = LanguageModelRegistry::read_global(cx)
-            .default_model()
-            .map(|default| default.provider.id())
+            .active_provider()
+            .map(|p| p.id())
        else {
            return;
        };
@@ -579,9 +568,7 @@ impl AssistantPanel {
            return;
        }

-        let Some(ConfiguredModel { provider, .. }) =
-            LanguageModelRegistry::read_global(cx).default_model()
-        else {
+        let Some(provider) = LanguageModelRegistry::read_global(cx).active_provider() else {
            return;
        };

@@ -989,8 +976,8 @@ impl AssistantPanel {
                |this, _, event: &ConfigurationViewEvent, window, cx| match event {
                    ConfigurationViewEvent::NewProviderContextEditor(provider) => {
                        if LanguageModelRegistry::read_global(cx)
-                            .default_model()
-                            .map_or(true, |default| default.provider.id() != provider.id())
+                            .active_provider()
+                            .map_or(true, |p| p.id() != provider.id())
                        {
                            if let Some(model) = provider.default_model(cx) {
                                update_settings_file::<AssistantSettings>(
@@ -1168,8 +1155,8 @@ impl AssistantPanel {

    fn is_authenticated(&mut self, cx: &mut Context<Self>) -> bool {
        LanguageModelRegistry::read_global(cx)
-            .default_model()
-            .map_or(false, |default| default.provider.is_authenticated(cx))
+            .active_provider()
+            .map_or(false, |provider| provider.is_authenticated(cx))
    }

    fn authenticate(
@@ -1177,8 +1164,8 @@ impl AssistantPanel {
        cx: &mut Context<Self>,
    ) -> Option<Task<Result<(), AuthenticateError>>> {
        LanguageModelRegistry::read_global(cx)
-            .default_model()
-            .map_or(None, |default| Some(default.provider.authenticate(cx)))
+            .active_provider()
+            .map_or(None, |provider| Some(provider.authenticate(cx)))
    }

    fn restart_context_servers(
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -34,8 +34,8 @@ use gpui::{
 };
 use language::{Buffer, IndentKind, Point, Selection, TransactionId, line_diff};
 use language_model::{
-    ConfiguredModel, LanguageModel, LanguageModelRegistry, LanguageModelRequest,
-    LanguageModelRequestMessage, LanguageModelTextStream, Role, report_assistant_event,
+    LanguageModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
+    LanguageModelTextStream, Role, report_assistant_event,
 };
 use language_model_selector::{LanguageModelSelector, LanguageModelSelectorPopoverMenu};
 use multi_buffer::MultiBufferRow;
@@ -312,9 +312,7 @@ impl InlineAssistant {
                start..end,
            ));

-            if let Some(ConfiguredModel { model, .. }) =
-                LanguageModelRegistry::read_global(cx).default_model()
-            {
+            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
                self.telemetry.report_assistant_event(AssistantEvent {
                    conversation_id: None,
                    kind: AssistantKind::Inline,
@@ -527,14 +525,14 @@ impl InlineAssistant {
            BlockProperties {
                style: BlockStyle::Sticky,
                placement: BlockPlacement::Above(range.start),
-                height: Some(prompt_editor_height),
+                height: prompt_editor_height,
                render: build_assist_editor_renderer(prompt_editor),
                priority: 0,
            },
            BlockProperties {
                style: BlockStyle::Sticky,
                placement: BlockPlacement::Below(range.end),
-                height: None,
+                height: 0,
                render: Arc::new(|cx| {
                    v_flex()
                        .h_full()
@@ -879,9 +877,7 @@ impl InlineAssistant {
            let active_alternative = assist.codegen.read(cx).active_alternative().clone();
            let message_id = active_alternative.read(cx).message_id.clone();

-            if let Some(ConfiguredModel { model, .. }) =
-                LanguageModelRegistry::read_global(cx).default_model()
-            {
+            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
                let language_name = assist.editor.upgrade().and_then(|editor| {
                    let multibuffer = editor.read(cx).buffer().read(cx);
                    let multibuffer_snapshot = multibuffer.snapshot(cx);
@@ -1274,7 +1270,10 @@ impl InlineAssistant {
                    multi_buffer.update(cx, |multi_buffer, cx| {
                        multi_buffer.push_excerpts(
                            old_buffer.clone(),
-                            Some(ExcerptRange::new(buffer_start..buffer_end)),
+                            Some(ExcerptRange {
+                                context: buffer_start..buffer_end,
+                                primary: None,
+                            }),
                            cx,
                        );
                    });
@@ -1301,7 +1300,7 @@ impl InlineAssistant {
                    deleted_lines_editor.update(cx, |editor, cx| editor.max_point(cx).row().0 + 1);
                new_blocks.push(BlockProperties {
                    placement: BlockPlacement::Above(new_row),
-                    height: Some(height),
+                    height,
                    style: BlockStyle::Flex,
                    render: Arc::new(move |cx| {
                        div()
@@ -1633,8 +1632,8 @@ impl Render for PromptEditor {
                                format!(
                                    "Using {}",
                                    LanguageModelRegistry::read_global(cx)
-                                        .default_model()
-                                        .map(|default| default.model.name().0)
+                                        .active_model()
+                                        .map(|model| model.name().0)
                                        .unwrap_or_else(|| "No model selected".into()),
                                ),
                                None,
@@ -2081,7 +2080,7 @@ impl PromptEditor {
        let disabled = matches!(codegen.status(cx), CodegenStatus::Idle);

        let model_registry = LanguageModelRegistry::read_global(cx);
-        let default_model = model_registry.default_model().map(|default| default.model);
+        let default_model = model_registry.active_model();
        let alternative_models = model_registry.inline_alternative_models();

        let get_model_name = |index: usize| -> String {
@@ -2187,9 +2186,7 @@ impl PromptEditor {
    }

    fn render_token_count(&self, cx: &mut Context<Self>) -> Option<impl IntoElement> {
-        let model = LanguageModelRegistry::read_global(cx)
-            .default_model()?
-            .model;
+        let model = LanguageModelRegistry::read_global(cx).active_model()?;
        let token_counts = self.token_counts?;
        let max_token_count = model.max_token_count();

@@ -2644,9 +2641,8 @@ impl Codegen {
        }

        let primary_model = LanguageModelRegistry::read_global(cx)
-            .default_model()
-            .context("no active model")?
-            .model;
+            .active_model()
+            .context("no active model")?;

        for (model, alternative) in iter::once(primary_model)
            .chain(alternative_models)
@@ -2870,9 +2866,7 @@ impl CodegenAlternative {
        assistant_panel_context: Option<LanguageModelRequest>,
        cx: &App,
    ) -> BoxFuture<'static, Result<TokenCounts>> {
-        if let Some(ConfiguredModel { model, .. }) =
-            LanguageModelRegistry::read_global(cx).inline_assistant_model()
-        {
+        if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
            let request = self.build_request(user_prompt, assistant_panel_context.clone(), cx);
            match request {
                Ok(request) => {
--- a/crates/assistant/src/terminal_inline_assistant.rs
+++ b/crates/assistant/src/terminal_inline_assistant.rs
@@ -16,8 +16,8 @@ use gpui::{
 };
 use language::Buffer;
 use language_model::{
-    ConfiguredModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
-    Role, report_assistant_event,
+    LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role,
+    report_assistant_event,
 };
 use language_model_selector::{LanguageModelSelector, LanguageModelSelectorPopoverMenu};
 use prompt_store::PromptBuilder;
@@ -318,9 +318,7 @@ impl TerminalInlineAssistant {
                })
                .log_err();

-            if let Some(ConfiguredModel { model, .. }) =
-                LanguageModelRegistry::read_global(cx).inline_assistant_model()
-            {
+            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
                let codegen = assist.codegen.read(cx);
                let executor = cx.background_executor().clone();
                report_assistant_event(
@@ -654,8 +652,8 @@ impl Render for PromptEditor {
                                format!(
                                    "Using {}",
                                    LanguageModelRegistry::read_global(cx)
-                                        .inline_assistant_model()
-                                        .map(|inline_assistant| inline_assistant.model.name().0)
+                                        .active_model()
+                                        .map(|model| model.name().0)
                                        .unwrap_or_else(|| "No model selected".into()),
                                ),
                                None,
@@ -824,9 +822,7 @@ impl PromptEditor {

    fn count_tokens(&mut self, cx: &mut Context<Self>) {
        let assist_id = self.id;
-        let Some(ConfiguredModel { model, .. }) =
-            LanguageModelRegistry::read_global(cx).inline_assistant_model()
-        else {
+        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
            return;
        };
        self.pending_token_count = cx.spawn(async move |this, cx| {
@@ -984,9 +980,7 @@ impl PromptEditor {
    }

    fn render_token_count(&self, cx: &mut Context<Self>) -> Option<impl IntoElement> {
-        let model = LanguageModelRegistry::read_global(cx)
-            .inline_assistant_model()?
-            .model;
+        let model = LanguageModelRegistry::read_global(cx).active_model()?;
        let token_count = self.token_count?;
        let max_token_count = model.max_token_count();

@@ -1137,9 +1131,7 @@ impl Codegen {
    }

    pub fn start(&mut self, prompt: LanguageModelRequest, cx: &mut Context<Self>) {
-        let Some(ConfiguredModel { model, .. }) =
-            LanguageModelRegistry::read_global(cx).inline_assistant_model()
-        else {
+        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
            return;
        };

--- a/crates/assistant2/Cargo.toml
+++ b/crates/assistant2/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "agent"
+name = "assistant2"
 version = "0.1.0"
 edition.workspace = true
 publish.workspace = true
@@ -81,13 +81,11 @@ theme.workspace = true
 time.workspace = true
 time_format.workspace = true
 ui.workspace = true
-ui_input.workspace = true
 util.workspace = true
 uuid.workspace = true
 vim_mode_setting.workspace = true
 workspace.workspace = true
 zed_actions.workspace = true
-workspace-hack.workspace = true

 [dev-dependencies]
 buffer_diff = { workspace = true, features = ["test-support"] }
--- a/crates/assistant2/LICENSE-GPL
+++ b/crates/assistant2/LICENSE-GPL
--- a/crates/assistant2/src/active_thread.rs
+++ b/crates/assistant2/src/active_thread.rs
--- a/crates/assistant2/src/assistant.rs
+++ b/crates/assistant2/src/assistant.rs
@@ -1,6 +1,6 @@
 mod active_thread;
-mod agent_diff;
 mod assistant_configuration;
+mod assistant_diff;
 mod assistant_model_selector;
 mod assistant_panel;
 mod buffer_codegen;
@@ -23,7 +23,7 @@ mod ui;

 use std::sync::Arc;

-use assistant_settings::{AgentProfileId, AssistantSettings};
+use assistant_settings::AssistantSettings;
 use client::Client;
 use command_palette_hooks::CommandPaletteFilter;
 use feature_flags::{Assistant2FeatureFlag, FeatureFlagAppExt};
@@ -33,7 +33,6 @@ use prompt_store::PromptBuilder;
 use schemars::JsonSchema;
 use serde::Deserialize;
 use settings::Settings as _;
-use thread::ThreadId;

 pub use crate::active_thread::ActiveThread;
 use crate::assistant_configuration::{AddContextServerModal, ManageProfilesModal};
@@ -41,16 +40,18 @@ pub use crate::assistant_panel::{AssistantPanel, ConcreteAssistantPanelDelegate}
 pub use crate::inline_assistant::InlineAssistant;
 pub use crate::thread::{Message, RequestKind, Thread, ThreadEvent};
 pub use crate::thread_store::ThreadStore;
-pub use agent_diff::{AgentDiff, AgentDiffToolbar};
+pub use assistant_diff::{AssistantDiff, AssistantDiffToolbar};

 actions!(
-    agent,
+    assistant2,
    [
+        NewThread,
        NewPromptEditor,
        ToggleContextPicker,
        ToggleProfileSelector,
        RemoveAllContext,
        OpenHistory,
+        OpenConfiguration,
        AddContextServer,
        RemoveSelectedThread,
        Chat,
@@ -64,39 +65,33 @@ actions!(
        RemoveFocusedContext,
        AcceptSuggestedContext,
        OpenActiveThreadAsMarkdown,
-        OpenAgentDiff,
-        Keep,
+        OpenAssistantDiff,
+        ToggleKeep,
        Reject,
        RejectAll,
        KeepAll
    ]
 );

-#[derive(Default, Clone, PartialEq, Deserialize, JsonSchema)]
-pub struct NewThread {
-    #[serde(default)]
-    from_thread_id: Option<ThreadId>,
-}
-
 #[derive(PartialEq, Clone, Default, Debug, Deserialize, JsonSchema)]
 pub struct ManageProfiles {
    #[serde(default)]
-    pub customize_tools: Option<AgentProfileId>,
+    pub customize_tools: Option<Arc<str>>,
 }

 impl ManageProfiles {
-    pub fn customize_tools(profile_id: AgentProfileId) -> Self {
+    pub fn customize_tools(profile_id: Arc<str>) -> Self {
        Self {
            customize_tools: Some(profile_id),
        }
    }
 }

-impl_actions!(agent, [NewThread, ManageProfiles]);
+impl_actions!(assistant, [ManageProfiles]);

-const NAMESPACE: &str = "agent";
+const NAMESPACE: &str = "assistant2";

-/// Initializes the `agent` crate.
+/// Initializes the `assistant2` crate.
 pub fn init(
    fs: Arc<dyn Fs>,
    client: Arc<Client>,
@@ -122,10 +117,10 @@ pub fn init(
    cx.observe_new(AddContextServerModal::register).detach();
    cx.observe_new(ManageProfilesModal::register).detach();

-    feature_gate_agent_actions(cx);
+    feature_gate_assistant2_actions(cx);
 }

-fn feature_gate_agent_actions(cx: &mut App) {
+fn feature_gate_assistant2_actions(cx: &mut App) {
    CommandPaletteFilter::update_global(cx, |filter, _cx| {
        filter.hide_namespace(NAMESPACE);
    });
--- a/crates/assistant2/src/assistant_configuration.rs
+++ b/crates/assistant2/src/assistant_configuration.rs
@@ -4,14 +4,11 @@ mod tool_picker;

 use std::sync::Arc;

-use assistant_settings::AssistantSettings;
 use assistant_tool::{ToolSource, ToolWorkingSet};
 use collections::HashMap;
 use context_server::manager::ContextServerManager;
-use fs::Fs;
 use gpui::{Action, AnyView, App, Entity, EventEmitter, FocusHandle, Focusable, Subscription};
 use language_model::{LanguageModelProvider, LanguageModelProviderId, LanguageModelRegistry};
-use settings::{Settings, update_settings_file};
 use ui::{Disclosure, Divider, DividerColor, ElevationIndex, Indicator, Switch, prelude::*};
 use util::ResultExt as _;
 use zed_actions::ExtensionCategoryFilter;
@@ -22,7 +19,6 @@ pub(crate) use manage_profiles_modal::ManageProfilesModal;
 use crate::AddContextServer;

 pub struct AssistantConfiguration {
-    fs: Arc<dyn Fs>,
    focus_handle: FocusHandle,
    configuration_views_by_provider: HashMap<LanguageModelProviderId, AnyView>,
    context_server_manager: Entity<ContextServerManager>,
@@ -33,7 +29,6 @@ pub struct AssistantConfiguration {

 impl AssistantConfiguration {
    pub fn new(
-        fs: Arc<dyn Fs>,
        context_server_manager: Entity<ContextServerManager>,
        tools: Arc<ToolWorkingSet>,
        window: &mut Window,
@@ -59,7 +54,6 @@ impl AssistantConfiguration {
        );

        let mut this = Self {
-            fs,
            focus_handle,
            configuration_views_by_provider: HashMap::default(),
            context_server_manager,
@@ -173,55 +167,6 @@ impl AssistantConfiguration {
            )
    }

-    fn render_command_permission(&mut self, cx: &mut Context<Self>) -> impl IntoElement {
-        let always_allow_tool_actions = AssistantSettings::get_global(cx).always_allow_tool_actions;
-
-        const HEADING: &str = "Allow running tools without asking for confirmation";
-
-        v_flex()
-            .p(DynamicSpacing::Base16.rems(cx))
-            .gap_2()
-            .flex_1()
-            .child(Headline::new("General Settings").size(HeadlineSize::Small))
-            .child(
-                h_flex()
-                    .p_2p5()
-                    .rounded_sm()
-                    .bg(cx.theme().colors().editor_background)
-                    .border_1()
-                    .border_color(cx.theme().colors().border)
-                    .gap_4()
-                    .justify_between()
-                    .flex_wrap()
-                    .child(
-                        v_flex()
-                            .gap_0p5()
-                            .max_w_5_6()
-                            .child(Label::new(HEADING))
-                            .child(Label::new("When enabled, the agent can perform potentially destructive actions without asking for your confirmation.").color(Color::Muted)),
-                    )
-                    .child(
-                        Switch::new(
-                            "always-allow-tool-actions-switch",
-                            always_allow_tool_actions.into(),
-                        )
-                        .on_click({
-                            let fs = self.fs.clone();
-                            move |state, _window, cx| {
-                                let allow = state == &ToggleState::Selected;
-                                update_settings_file::<AssistantSettings>(
-                                    fs.clone(),
-                                    cx,
-                                    move |settings, _| {
-                                        settings.set_always_allow_tool_actions(allow);
-                                    },
-                                );
-                            }
-                        }),
-                    ),
-            )
-    }
-
    fn render_context_servers_section(&mut self, cx: &mut Context<Self>) -> impl IntoElement {
        let context_servers = self.context_server_manager.read(cx).all_servers().clone();
        let tools_by_source = self.tools.tools_by_source(cx);
@@ -413,8 +358,6 @@ impl Render for AssistantConfiguration {
            .bg(cx.theme().colors().panel_background)
            .size_full()
            .overflow_y_scroll()
-            .child(self.render_command_permission(cx))
-            .child(Divider::horizontal().color(DividerColor::Border))
            .child(self.render_context_servers_section(cx))
            .child(Divider::horizontal().color(DividerColor::Border))
            .child(
--- a/crates/assistant2/src/assistant_configuration/add_context_server_modal.rs
+++ b/crates/assistant2/src/assistant_configuration/add_context_server_modal.rs
@@ -1,17 +1,17 @@
 use context_server::{ContextServerSettings, ServerCommand, ServerConfig};
+use editor::Editor;
 use gpui::{DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, WeakEntity, prelude::*};
 use serde_json::json;
 use settings::update_settings_file;
 use ui::{Modal, ModalFooter, ModalHeader, Section, Tooltip, prelude::*};
-use ui_input::SingleLineInput;
 use workspace::{ModalView, Workspace};

 use crate::AddContextServer;

 pub struct AddContextServerModal {
    workspace: WeakEntity<Workspace>,
-    name_editor: Entity<SingleLineInput>,
-    command_editor: Entity<SingleLineInput>,
+    name_editor: Entity<Editor>,
+    command_editor: Entity<Editor>,
 }

 impl AddContextServerModal {
@@ -33,10 +33,15 @@ impl AddContextServerModal {
        window: &mut Window,
        cx: &mut Context<Self>,
    ) -> Self {
-        let name_editor =
-            cx.new(|cx| SingleLineInput::new(window, cx, "Your server name").label("Name"));
-        let command_editor = cx.new(|cx| {
-            SingleLineInput::new(window, cx, "Command").label("Command to run the context server")
+        let name_editor = cx.new(|cx| Editor::single_line(window, cx));
+        let command_editor = cx.new(|cx| Editor::single_line(window, cx));
+
+        name_editor.update(cx, |editor, cx| {
+            editor.set_placeholder_text("Context server name", cx);
+        });
+
+        command_editor.update(cx, |editor, cx| {
+            editor.set_placeholder_text("Command to run the context server", cx);
        });

        Self {
@@ -47,22 +52,8 @@ impl AddContextServerModal {
    }

    fn confirm(&mut self, cx: &mut Context<Self>) {
-        let name = self
-            .name_editor
-            .read(cx)
-            .editor()
-            .read(cx)
-            .text(cx)
-            .trim()
-            .to_string();
-        let command = self
-            .command_editor
-            .read(cx)
-            .editor()
-            .read(cx)
-            .text(cx)
-            .trim()
-            .to_string();
+        let name = self.name_editor.read(cx).text(cx).trim().to_string();
+        let command = self.command_editor.read(cx).text(cx).trim().to_string();

        if name.is_empty() || command.is_empty() {
            return;
@@ -113,8 +104,8 @@ impl EventEmitter<DismissEvent> for AddContextServerModal {}

 impl Render for AddContextServerModal {
    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let is_name_empty = self.name_editor.read(cx).is_empty(cx);
-        let is_command_empty = self.command_editor.read(cx).is_empty(cx);
+        let is_name_empty = self.name_editor.read(cx).text(cx).trim().is_empty();
+        let is_command_empty = self.command_editor.read(cx).text(cx).trim().is_empty();

        div()
            .elevation_3(cx)
@@ -131,8 +122,18 @@ impl Render for AddContextServerModal {
                    .header(ModalHeader::new().headline("Add Context Server"))
                    .section(
                        Section::new()
-                            .child(self.name_editor.clone())
-                            .child(self.command_editor.clone()),
+                            .child(
+                                v_flex()
+                                    .gap_1()
+                                    .child(Label::new("Name"))
+                                    .child(self.name_editor.clone()),
+                            )
+                            .child(
+                                v_flex()
+                                    .gap_1()
+                                    .child(Label::new("Command"))
+                                    .child(self.command_editor.clone()),
+                            ),
                    )
                    .footer(
                        ModalFooter::new()
--- a/crates/assistant2/src/assistant_configuration/manage_profiles_modal.rs
+++ b/crates/assistant2/src/assistant_configuration/manage_profiles_modal.rs
@@ -2,7 +2,7 @@ mod profile_modal_header;

 use std::sync::Arc;

-use assistant_settings::{AgentProfile, AgentProfileId, AssistantSettings};
+use assistant_settings::{AgentProfile, AssistantSettings};
 use assistant_tool::ToolWorkingSet;
 use convert_case::{Case, Casing as _};
 use editor::Editor;
@@ -27,7 +27,7 @@ enum Mode {
    NewProfile(NewProfileMode),
    ViewProfile(ViewProfileMode),
    ConfigureTools {
-        profile_id: AgentProfileId,
+        profile_id: Arc<str>,
        tool_picker: Entity<ToolPicker>,
        _subscription: Subscription,
    },
@@ -58,7 +58,7 @@ impl Mode {

 #[derive(Clone)]
 struct ProfileEntry {
-    pub id: AgentProfileId,
+    pub id: Arc<str>,
    pub name: SharedString,
    pub navigation: NavigableEntry,
 }
@@ -71,7 +71,7 @@ pub struct ChooseProfileMode {

 #[derive(Clone)]
 pub struct ViewProfileMode {
-    profile_id: AgentProfileId,
+    profile_id: Arc<str>,
    fork_profile: NavigableEntry,
    configure_tools: NavigableEntry,
 }
@@ -79,7 +79,7 @@ pub struct ViewProfileMode {
 #[derive(Clone)]
 pub struct NewProfileMode {
    name_editor: Entity<Editor>,
-    base_profile_id: Option<AgentProfileId>,
+    base_profile_id: Option<Arc<str>>,
 }

 pub struct ManageProfilesModal {
@@ -140,7 +140,7 @@ impl ManageProfilesModal {

    fn new_profile(
        &mut self,
-        base_profile_id: Option<AgentProfileId>,
+        base_profile_id: Option<Arc<str>>,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
@@ -158,7 +158,7 @@ impl ManageProfilesModal {

    pub fn view_profile(
        &mut self,
-        profile_id: AgentProfileId,
+        profile_id: Arc<str>,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
@@ -172,7 +172,7 @@ impl ManageProfilesModal {

    fn configure_tools(
        &mut self,
-        profile_id: AgentProfileId,
+        profile_id: Arc<str>,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
@@ -219,7 +219,7 @@ impl ManageProfilesModal {
                    .and_then(|profile_id| settings.profiles.get(profile_id).cloned());

                let name = mode.name_editor.read(cx).text(cx);
-                let profile_id = AgentProfileId(name.to_case(Case::Kebab).into());
+                let profile_id: Arc<str> = name.to_case(Case::Kebab).into();

                let profile = AgentProfile {
                    name: name.into(),
@@ -227,10 +227,6 @@ impl ManageProfilesModal {
                        .as_ref()
                        .map(|profile| profile.tools.clone())
                        .unwrap_or_default(),
-                    enable_all_context_servers: base_profile
-                        .as_ref()
-                        .map(|profile| profile.enable_all_context_servers)
-                        .unwrap_or_default(),
                    context_servers: base_profile
                        .map(|profile| profile.context_servers)
                        .unwrap_or_default(),
@@ -261,12 +257,7 @@ impl ManageProfilesModal {
        }
    }

-    fn create_profile(
-        &self,
-        profile_id: AgentProfileId,
-        profile: AgentProfile,
-        cx: &mut Context<Self>,
-    ) {
+    fn create_profile(&self, profile_id: Arc<str>, profile: AgentProfile, cx: &mut Context<Self>) {
        update_settings_file::<AssistantSettings>(self.fs.clone(), cx, {
            move |settings, _cx| {
                settings.create_profile(profile_id, profile).log_err();
--- a/crates/assistant2/src/assistant_configuration/manage_profiles_modal/profile_modal_header.rs
+++ b/crates/assistant2/src/assistant_configuration/manage_profiles_modal/profile_modal_header.rs
--- a/crates/assistant2/src/assistant_configuration/tool_picker.rs
+++ b/crates/assistant2/src/assistant_configuration/tool_picker.rs
@@ -1,7 +1,7 @@
 use std::sync::Arc;

 use assistant_settings::{
-    AgentProfile, AgentProfileContent, AgentProfileId, AssistantSettings, AssistantSettingsContent,
+    AgentProfile, AgentProfileContent, AssistantSettings, AssistantSettingsContent,
    ContextServerPresetContent, VersionedAssistantSettingsContent,
 };
 use assistant_tool::{ToolSource, ToolWorkingSet};
@@ -51,7 +51,7 @@ pub struct ToolPickerDelegate {
    thread_store: WeakEntity<ThreadStore>,
    fs: Arc<dyn Fs>,
    tools: Vec<ToolEntry>,
-    profile_id: AgentProfileId,
+    profile_id: Arc<str>,
    profile: AgentProfile,
    matches: Vec<StringMatch>,
    selected_index: usize,
@@ -62,7 +62,7 @@ impl ToolPickerDelegate {
        fs: Arc<dyn Fs>,
        tool_set: Arc<ToolWorkingSet>,
        thread_store: WeakEntity<ThreadStore>,
-        profile_id: AgentProfileId,
+        profile_id: Arc<str>,
        profile: AgentProfile,
        cx: &mut Context<ToolPicker>,
    ) -> Self {
@@ -191,8 +191,8 @@ impl PickerDelegate for ToolPickerDelegate {
        let active_profile_id = &AssistantSettings::get_global(cx).default_profile;
        if active_profile_id == &self.profile_id {
            self.thread_store
-                .update(cx, |this, cx| {
-                    this.load_profile(&self.profile, cx);
+                .update(cx, |this, _cx| {
+                    this.load_profile(&self.profile);
                })
                .log_err();
        }
@@ -202,43 +202,40 @@ impl PickerDelegate for ToolPickerDelegate {
            let default_profile = self.profile.clone();
            let tool = tool.clone();
            move |settings, _cx| match settings {
-                AssistantSettingsContent::Versioned(boxed) => {
-                    if let VersionedAssistantSettingsContent::V2(ref mut settings) = **boxed {
-                        let profiles = settings.profiles.get_or_insert_default();
-                        let profile =
-                            profiles
-                                .entry(profile_id)
-                                .or_insert_with(|| AgentProfileContent {
-                                    name: default_profile.name.into(),
-                                    tools: default_profile.tools,
-                                    enable_all_context_servers: Some(
-                                        default_profile.enable_all_context_servers,
-                                    ),
-                                    context_servers: default_profile
-                                        .context_servers
-                                        .into_iter()
-                                        .map(|(server_id, preset)| {
-                                            (
-                                                server_id,
-                                                ContextServerPresetContent {
-                                                    tools: preset.tools,
-                                                },
-                                            )
-                                        })
-                                        .collect(),
-                                });
-
-                        match tool.source {
-                            ToolSource::Native => {
-                                *profile.tools.entry(tool.name).or_default() = is_enabled;
-                            }
-                            ToolSource::ContextServer { id } => {
-                                let preset = profile
+                AssistantSettingsContent::Versioned(VersionedAssistantSettingsContent::V2(
+                    settings,
+                )) => {
+                    let profiles = settings.profiles.get_or_insert_default();
+                    let profile =
+                        profiles
+                            .entry(profile_id)
+                            .or_insert_with(|| AgentProfileContent {
+                                name: default_profile.name.into(),
+                                tools: default_profile.tools,
+                                context_servers: default_profile
                                    .context_servers
-                                    .entry(id.clone().into())
-                                    .or_default();
-                                *preset.tools.entry(tool.name.clone()).or_default() = is_enabled;
-                            }
+                                    .into_iter()
+                                    .map(|(server_id, preset)| {
+                                        (
+                                            server_id,
+                                            ContextServerPresetContent {
+                                                tools: preset.tools,
+                                            },
+                                        )
+                                    })
+                                    .collect(),
+                            });
+
+                    match tool.source {
+                        ToolSource::Native => {
+                            *profile.tools.entry(tool.name).or_default() = is_enabled;
+                        }
+                        ToolSource::ContextServer { id } => {
+                            let preset = profile
+                                .context_servers
+                                .entry(id.clone().into())
+                                .or_default();
+                            *preset.tools.entry(tool.name.clone()).or_default() = is_enabled;
                        }
                    }
                }
--- a/crates/assistant2/src/assistant_diff.rs
+++ b/crates/assistant2/src/assistant_diff.rs
@@ -1,11 +1,10 @@
-use crate::{Keep, Reject, Thread, ThreadEvent};
+use crate::{Thread, ThreadEvent, ToggleKeep};
 use anyhow::Result;
 use buffer_diff::DiffHunkStatus;
 use collections::HashSet;
 use editor::{
    Direction, Editor, EditorEvent, MultiBuffer, ToPoint,
    actions::{GoToHunk, GoToPreviousHunk},
-    scroll::Autoscroll,
 };
 use gpui::{
    Action, AnyElement, AnyView, App, Entity, EventEmitter, FocusHandle, Focusable, SharedString,
@@ -26,9 +25,8 @@ use workspace::{
    item::{BreadcrumbText, ItemEvent, TabContentParams},
    searchable::SearchableItemHandle,
 };
-use zed_actions::assistant::ToggleFocus;

-pub struct AgentDiff {
+pub struct AssistantDiff {
    multibuffer: Entity<MultiBuffer>,
    editor: Entity<Editor>,
    thread: Entity<Thread>,
@@ -38,35 +36,28 @@ pub struct AgentDiff {
    _subscriptions: Vec<Subscription>,
 }

-impl AgentDiff {
+impl AssistantDiff {
    pub fn deploy(
        thread: Entity<Thread>,
        workspace: WeakEntity<Workspace>,
        window: &mut Window,
        cx: &mut App,
-    ) -> Result<Entity<Self>> {
-        workspace.update(cx, |workspace, cx| {
-            Self::deploy_in_workspace(thread, workspace, window, cx)
-        })
-    }
-
-    pub fn deploy_in_workspace(
-        thread: Entity<Thread>,
-        workspace: &mut Workspace,
-        window: &mut Window,
-        cx: &mut Context<Workspace>,
-    ) -> Entity<Self> {
-        let existing_diff = workspace
-            .items_of_type::<AgentDiff>(cx)
-            .find(|diff| diff.read(cx).thread == thread);
+    ) -> Result<()> {
+        let existing_diff = workspace.update(cx, |workspace, cx| {
+            workspace
+                .items_of_type::<AssistantDiff>(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
+            workspace.update(cx, |workspace, cx| {
+                workspace.activate_item(&existing_diff, true, true, window, cx);
+            })
        } else {
-            let agent_diff =
-                cx.new(|cx| AgentDiff::new(thread.clone(), workspace.weak_handle(), window, cx));
-            workspace.add_item_to_center(Box::new(agent_diff.clone()), window, cx);
-            agent_diff
+            let assistant_diff =
+                cx.new(|cx| AssistantDiff::new(thread.clone(), workspace.clone(), window, cx));
+            workspace.update(cx, |workspace, cx| {
+                workspace.add_item_to_center(Box::new(assistant_diff), window, cx);
+            })
        }
    }

@@ -81,13 +72,13 @@ impl AgentDiff {

        let project = thread.read(cx).project().clone();
        let render_diff_hunk_controls = Arc::new({
-            let agent_diff = cx.entity();
+            let assistant_diff = cx.entity();
            move |row,
                  status: &DiffHunkStatus,
                  hunk_range,
                  is_created_file,
                  line_height,
-                  editor: &Entity<Editor>,
+                  _editor: &Entity<Editor>,
                  window: &mut Window,
                  cx: &mut App| {
                render_diff_hunk_controls(
@@ -96,8 +87,7 @@ impl AgentDiff {
                    hunk_range,
                    is_created_file,
                    line_height,
-                    &agent_diff,
-                    editor,
+                    &assistant_diff,
                    window,
                    cx,
                )
@@ -109,7 +99,7 @@ impl AgentDiff {
            editor.disable_inline_diagnostics();
            editor.set_expand_all_diff_hunks(cx);
            editor.set_render_diff_hunk_controls(render_diff_hunk_controls, cx);
-            editor.register_addon(AgentDiffAddon);
+            editor.register_addon(AssistantDiffAddon);
            editor
        });

@@ -140,17 +130,16 @@ impl AgentDiff {
        let changed_buffers = thread.action_log().read(cx).changed_buffers(cx);
        let mut paths_to_delete = self.multibuffer.read(cx).paths().collect::<HashSet<_>>();

-        for (buffer, diff_handle) in changed_buffers {
-            if buffer.read(cx).file().is_none() {
+        for (buffer, changed) in changed_buffers {
+            let Some(file) = buffer.read(cx).file().cloned() else {
                continue;
-            }
+            };

-            let path_key = PathKey::for_buffer(&buffer, cx);
+            let path_key = PathKey::namespaced("", file.full_path(cx).into());
            paths_to_delete.remove(&path_key);

            let snapshot = buffer.read(cx).snapshot();
-            let diff = diff_handle.read(cx);
-
+            let diff = changed.diff.read(cx);
            let diff_hunk_ranges = diff
                .hunks_intersecting_range(
                    language::Anchor::MIN..language::Anchor::MAX,
@@ -163,38 +152,22 @@ impl AgentDiff {
            let (was_empty, is_excerpt_newly_added) =
                self.multibuffer.update(cx, |multibuffer, cx| {
                    let was_empty = multibuffer.is_empty();
-                    let (_, is_excerpt_newly_added) = multibuffer.set_excerpts_for_path(
+                    let is_excerpt_newly_added = multibuffer.set_excerpts_for_path(
                        path_key.clone(),
                        buffer.clone(),
                        diff_hunk_ranges,
                        editor::DEFAULT_MULTIBUFFER_CONTEXT,
                        cx,
                    );
-                    multibuffer.add_diff(diff_handle, cx);
+                    multibuffer.add_diff(changed.diff.clone(), cx);
                    (was_empty, is_excerpt_newly_added)
                });

            self.editor.update(cx, |editor, cx| {
                if was_empty {
-                    let first_hunk = editor
-                        .diff_hunks_in_ranges(
-                            &[editor::Anchor::min()..editor::Anchor::max()],
-                            &self.multibuffer.read(cx).read(cx),
-                        )
-                        .next();
-
-                    if let Some(first_hunk) = first_hunk {
-                        let first_hunk_start = first_hunk.multi_buffer_range().start;
-                        editor.change_selections(
-                            Some(Autoscroll::fit()),
-                            window,
-                            cx,
-                            |selections| {
-                                selections
-                                    .select_anchor_ranges([first_hunk_start..first_hunk_start]);
-                            },
-                        )
-                    }
+                    editor.change_selections(None, window, cx, |selections| {
+                        selections.select_ranges([0..0])
+                    });
                }

                if is_excerpt_newly_added
@@ -243,57 +216,51 @@ impl AgentDiff {

    fn handle_thread_event(&mut self, event: &ThreadEvent, cx: &mut Context<Self>) {
        match event {
-            ThreadEvent::SummaryGenerated => self.update_title(cx),
+            ThreadEvent::SummaryChanged => self.update_title(cx),
            _ => {}
        }
    }

-    pub fn move_to_path(&mut self, path_key: PathKey, window: &mut Window, cx: &mut Context<Self>) {
-        if let Some(position) = self.multibuffer.read(cx).location_for_path(&path_key, cx) {
-            self.editor.update(cx, |editor, cx| {
-                let first_hunk = editor
-                    .diff_hunks_in_ranges(
-                        &[position..editor::Anchor::max()],
-                        &self.multibuffer.read(cx).read(cx),
-                    )
-                    .next();
-
-                if let Some(first_hunk) = first_hunk {
-                    let first_hunk_start = first_hunk.multi_buffer_range().start;
-                    editor.change_selections(Some(Autoscroll::fit()), window, cx, |selections| {
-                        selections.select_anchor_ranges([first_hunk_start..first_hunk_start]);
-                    })
-                }
-            });
-        }
-    }
-
-    fn keep(&mut self, _: &crate::Keep, window: &mut Window, cx: &mut Context<Self>) {
+    fn toggle_keep(&mut self, _: &crate::ToggleKeep, _window: &mut Window, cx: &mut Context<Self>) {
        let ranges = self
            .editor
            .read(cx)
            .selections
            .disjoint_anchor_ranges()
            .collect::<Vec<_>>();
-        self.keep_edits_in_ranges(ranges, window, cx);
+
+        let snapshot = self.multibuffer.read(cx).snapshot(cx);
+        let diff_hunks_in_ranges = self
+            .editor
+            .read(cx)
+            .diff_hunks_in_ranges(&ranges, &snapshot)
+            .collect::<Vec<_>>();
+
+        for hunk in diff_hunks_in_ranges {
+            let buffer = self.multibuffer.read(cx).buffer(hunk.buffer_id);
+            if let Some(buffer) = buffer {
+                self.thread.update(cx, |thread, cx| {
+                    let accept = hunk.status().has_secondary_hunk();
+                    thread.review_edits_in_range(buffer, hunk.buffer_range, accept, cx)
+                });
+            }
+        }
    }

    fn reject(&mut self, _: &crate::Reject, window: &mut Window, cx: &mut Context<Self>) {
        let ranges = self
            .editor
-            .read(cx)
-            .selections
-            .disjoint_anchor_ranges()
-            .collect::<Vec<_>>();
-        self.reject_edits_in_ranges(ranges, window, cx);
+            .update(cx, |editor, cx| editor.selections.ranges(cx));
+        self.editor.update(cx, |editor, cx| {
+            editor.restore_hunks_in_ranges(ranges, window, cx)
+        })
    }

    fn reject_all(&mut self, _: &crate::RejectAll, window: &mut Window, cx: &mut Context<Self>) {
-        self.reject_edits_in_ranges(
-            vec![editor::Anchor::min()..editor::Anchor::max()],
-            window,
-            cx,
-        );
+        self.editor.update(cx, |editor, cx| {
+            let max_point = editor.buffer().read(cx).read(cx).max_point();
+            editor.restore_hunks_in_ranges(vec![Point::zero()..max_point], window, cx)
+        })
    }

    fn keep_all(&mut self, _: &crate::KeepAll, _window: &mut Window, cx: &mut Context<Self>) {
@@ -301,115 +268,33 @@ impl AgentDiff {
            .update(cx, |thread, cx| thread.keep_all_edits(cx));
    }

-    fn keep_edits_in_ranges(
+    fn review_diff_hunks(
        &mut self,
-        ranges: Vec<Range<editor::Anchor>>,
-        window: &mut Window,
+        hunk_ranges: Vec<Range<editor::Anchor>>,
+        accept: bool,
        cx: &mut Context<Self>,
    ) {
        let snapshot = self.multibuffer.read(cx).snapshot(cx);
        let diff_hunks_in_ranges = self
            .editor
            .read(cx)
-            .diff_hunks_in_ranges(&ranges, &snapshot)
+            .diff_hunks_in_ranges(&hunk_ranges, &snapshot)
            .collect::<Vec<_>>();
-        let newest_cursor = self.editor.update(cx, |editor, cx| {
-            editor.selections.newest::<Point>(cx).head()
-        });
-        if diff_hunks_in_ranges.iter().any(|hunk| {
-            hunk.row_range
-                .contains(&multi_buffer::MultiBufferRow(newest_cursor.row))
-        }) {
-            self.update_selection(&diff_hunks_in_ranges, window, cx);
-        }

-        for hunk in &diff_hunks_in_ranges {
+        for hunk in diff_hunks_in_ranges {
            let buffer = self.multibuffer.read(cx).buffer(hunk.buffer_id);
            if let Some(buffer) = buffer {
                self.thread.update(cx, |thread, cx| {
-                    thread.keep_edits_in_range(buffer, hunk.buffer_range.clone(), cx)
+                    thread.review_edits_in_range(buffer, hunk.buffer_range, accept, cx)
                });
            }
        }
    }
-
-    fn reject_edits_in_ranges(
-        &mut self,
-        ranges: Vec<Range<editor::Anchor>>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        let snapshot = self.multibuffer.read(cx).snapshot(cx);
-        let diff_hunks_in_ranges = self
-            .editor
-            .read(cx)
-            .diff_hunks_in_ranges(&ranges, &snapshot)
-            .collect::<Vec<_>>();
-        let newest_cursor = self.editor.update(cx, |editor, cx| {
-            editor.selections.newest::<Point>(cx).head()
-        });
-        if diff_hunks_in_ranges.iter().any(|hunk| {
-            hunk.row_range
-                .contains(&multi_buffer::MultiBufferRow(newest_cursor.row))
-        }) {
-            self.update_selection(&diff_hunks_in_ranges, window, cx);
-        }
-
-        for hunk in &diff_hunks_in_ranges {
-            let buffer = self.multibuffer.read(cx).buffer(hunk.buffer_id);
-            if let Some(buffer) = buffer {
-                self.thread
-                    .update(cx, |thread, cx| {
-                        thread.reject_edits_in_range(buffer, hunk.buffer_range.clone(), cx)
-                    })
-                    .detach_and_log_err(cx);
-            }
-        }
-    }
-
-    fn update_selection(
-        &mut self,
-        diff_hunks: &[multi_buffer::MultiBufferDiffHunk],
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        let snapshot = self.multibuffer.read(cx).snapshot(cx);
-        let target_hunk = diff_hunks
-            .last()
-            .and_then(|last_kept_hunk| {
-                let last_kept_hunk_end = last_kept_hunk.multi_buffer_range().end;
-                self.editor
-                    .read(cx)
-                    .diff_hunks_in_ranges(&[last_kept_hunk_end..editor::Anchor::max()], &snapshot)
-                    .skip(1)
-                    .next()
-            })
-            .or_else(|| {
-                let first_kept_hunk = diff_hunks.first()?;
-                let first_kept_hunk_start = first_kept_hunk.multi_buffer_range().start;
-                self.editor
-                    .read(cx)
-                    .diff_hunks_in_ranges(
-                        &[editor::Anchor::min()..first_kept_hunk_start],
-                        &snapshot,
-                    )
-                    .next()
-            });
-
-        if let Some(target_hunk) = target_hunk {
-            self.editor.update(cx, |editor, cx| {
-                editor.change_selections(Some(Autoscroll::fit()), window, cx, |selections| {
-                    let next_hunk_start = target_hunk.multi_buffer_range().start;
-                    selections.select_anchor_ranges([next_hunk_start..next_hunk_start]);
-                })
-            });
-        }
-    }
 }

-impl EventEmitter<EditorEvent> for AgentDiff {}
+impl EventEmitter<EditorEvent> for AssistantDiff {}

-impl Focusable for AgentDiff {
+impl Focusable for AssistantDiff {
    fn focus_handle(&self, cx: &App) -> FocusHandle {
        if self.multibuffer.read(cx).is_empty() {
            self.focus_handle.clone()
@@ -419,7 +304,7 @@ impl Focusable for AgentDiff {
    }
 }

-impl Item for AgentDiff {
+impl Item for AssistantDiff {
    type Event = EditorEvent;

    fn tab_icon(&self, _window: &Window, _cx: &App) -> Option<Icon> {
@@ -446,7 +331,7 @@ impl Item for AgentDiff {
    }

    fn tab_tooltip_text(&self, _: &App) -> Option<SharedString> {
-        Some("Agent Diff".into())
+        Some("Assistant Diff".into())
    }

    fn tab_content(&self, params: TabContentParams, _window: &Window, cx: &App) -> AnyElement {
@@ -583,15 +468,18 @@ impl Item for AgentDiff {
    }
 }

-impl Render for AgentDiff {
-    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+impl Render for AssistantDiff {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
        let is_empty = self.multibuffer.read(cx).is_empty();
-        let focus_handle = &self.focus_handle;

        div()
-            .track_focus(focus_handle)
-            .key_context(if is_empty { "EmptyPane" } else { "AgentDiff" })
-            .on_action(cx.listener(Self::keep))
+            .track_focus(&self.focus_handle)
+            .key_context(if is_empty {
+                "EmptyPane"
+            } else {
+                "AssistantDiff"
+            })
+            .on_action(cx.listener(Self::toggle_keep))
            .on_action(cx.listener(Self::reject))
            .on_action(cx.listener(Self::reject_all))
            .on_action(cx.listener(Self::keep_all))
@@ -600,48 +488,23 @@ impl Render for AgentDiff {
            .items_center()
            .justify_center()
            .size_full()
-            .when(is_empty, |el| {
-                el.child(
-                    v_flex()
-                        .items_center()
-                        .gap_2()
-                        .child("No changes to review")
-                        .child(
-                            Button::new("continue-iterating", "Continue Iterating")
-                                .style(ButtonStyle::Filled)
-                                .icon(IconName::ForwardArrow)
-                                .icon_position(IconPosition::Start)
-                                .icon_size(IconSize::Small)
-                                .icon_color(Color::Muted)
-                                .full_width()
-                                .key_binding(KeyBinding::for_action_in(
-                                    &ToggleFocus,
-                                    &focus_handle.clone(),
-                                    window,
-                                    cx,
-                                ))
-                                .on_click(|_event, window, cx| {
-                                    window.dispatch_action(ToggleFocus.boxed_clone(), cx)
-                                }),
-                        ),
-                )
-            })
+            .when(is_empty, |el| el.child("No changes to review"))
            .when(!is_empty, |el| el.child(self.editor.clone()))
    }
 }

 fn render_diff_hunk_controls(
    row: u32,
-    _status: &DiffHunkStatus,
+    status: &DiffHunkStatus,
    hunk_range: Range<editor::Anchor>,
    is_created_file: bool,
    line_height: Pixels,
-    agent_diff: &Entity<AgentDiff>,
-    editor: &Entity<Editor>,
+    assistant_diff: &Entity<AssistantDiff>,
    window: &mut Window,
    cx: &mut App,
 ) -> AnyElement {
-    let editor = editor.clone();
+    let editor = assistant_diff.read(cx).editor.clone();
+
    h_flex()
        .h(line_height)
        .mr_0p5()
@@ -656,48 +519,75 @@ fn render_diff_hunk_controls(
        .gap_1()
        .occlude()
        .shadow_md()
-        .children(vec![
-            Button::new(("reject", row as u64), "Reject")
-                .disabled(is_created_file)
-                .key_binding(
-                    KeyBinding::for_action_in(
-                        &Reject,
+        .children(if status.has_secondary_hunk() {
+            vec![
+                Button::new("reject", "Reject")
+                    .disabled(is_created_file)
+                    .key_binding(
+                        KeyBinding::for_action_in(
+                            &crate::Reject,
+                            &editor.read(cx).focus_handle(cx),
+                            window,
+                            cx,
+                        )
+                        .map(|kb| kb.size(rems_from_px(12.))),
+                    )
+                    .on_click({
+                        let editor = editor.clone();
+                        move |_event, window, cx| {
+                            editor.update(cx, |editor, cx| {
+                                let snapshot = editor.snapshot(window, cx);
+                                let point = hunk_range.start.to_point(&snapshot.buffer_snapshot);
+                                editor.restore_hunks_in_ranges(vec![point..point], window, cx);
+                            });
+                        }
+                    }),
+                Button::new(("keep", row as u64), "Keep")
+                    .key_binding(
+                        KeyBinding::for_action_in(
+                            &crate::ToggleKeep,
+                            &editor.read(cx).focus_handle(cx),
+                            window,
+                            cx,
+                        )
+                        .map(|kb| kb.size(rems_from_px(12.))),
+                    )
+                    .on_click({
+                        let assistant_diff = assistant_diff.clone();
+                        move |_event, _window, cx| {
+                            assistant_diff.update(cx, |diff, cx| {
+                                diff.review_diff_hunks(
+                                    vec![hunk_range.start..hunk_range.start],
+                                    true,
+                                    cx,
+                                );
+                            });
+                        }
+                    }),
+            ]
+        } else {
+            vec![
+                Button::new(("review", row as u64), "Review")
+                    .key_binding(KeyBinding::for_action_in(
+                        &ToggleKeep,
                        &editor.read(cx).focus_handle(cx),
                        window,
                        cx,
-                    )
-                    .map(|kb| kb.size(rems_from_px(12.))),
-                )
-                .on_click({
-                    let agent_diff = agent_diff.clone();
-                    move |_event, window, cx| {
-                        agent_diff.update(cx, |diff, cx| {
-                            diff.reject_edits_in_ranges(
-                                vec![hunk_range.start..hunk_range.start],
-                                window,
-                                cx,
-                            );
-                        });
-                    }
-                }),
-            Button::new(("keep", row as u64), "Keep")
-                .key_binding(
-                    KeyBinding::for_action_in(&Keep, &editor.read(cx).focus_handle(cx), window, cx)
-                        .map(|kb| kb.size(rems_from_px(12.))),
-                )
-                .on_click({
-                    let agent_diff = agent_diff.clone();
-                    move |_event, window, cx| {
-                        agent_diff.update(cx, |diff, cx| {
-                            diff.keep_edits_in_ranges(
-                                vec![hunk_range.start..hunk_range.start],
-                                window,
-                                cx,
-                            );
-                        });
-                    }
-                }),
-        ])
+                    ))
+                    .on_click({
+                        let assistant_diff = assistant_diff.clone();
+                        move |_event, _window, cx| {
+                            assistant_diff.update(cx, |diff, cx| {
+                                diff.review_diff_hunks(
+                                    vec![hunk_range.start..hunk_range.start],
+                                    false,
+                                    cx,
+                                );
+                            });
+                        }
+                    }),
+            ]
+        })
        .when(
            !editor.read(cx).buffer().read(cx).all_diff_hunks_expanded(),
            |el| {
@@ -778,38 +668,38 @@ fn render_diff_hunk_controls(
        .into_any_element()
 }

-struct AgentDiffAddon;
+struct AssistantDiffAddon;

-impl editor::Addon for AgentDiffAddon {
+impl editor::Addon for AssistantDiffAddon {
    fn to_any(&self) -> &dyn std::any::Any {
        self
    }

    fn extend_key_context(&self, key_context: &mut gpui::KeyContext, _: &App) {
-        key_context.add("agent_diff");
+        key_context.add("assistant_diff");
    }
 }

-pub struct AgentDiffToolbar {
-    agent_diff: Option<WeakEntity<AgentDiff>>,
+pub struct AssistantDiffToolbar {
+    assistant_diff: Option<WeakEntity<AssistantDiff>>,
    _workspace: WeakEntity<Workspace>,
 }

-impl AgentDiffToolbar {
+impl AssistantDiffToolbar {
    pub fn new(workspace: &Workspace, _: &mut Context<Self>) -> Self {
        Self {
-            agent_diff: None,
+            assistant_diff: None,
            _workspace: workspace.weak_handle(),
        }
    }

-    fn agent_diff(&self, _: &App) -> Option<Entity<AgentDiff>> {
-        self.agent_diff.as_ref()?.upgrade()
+    fn assistant_diff(&self, _: &App) -> Option<Entity<AssistantDiff>> {
+        self.assistant_diff.as_ref()?.upgrade()
    }

    fn dispatch_action(&self, action: &dyn Action, window: &mut Window, cx: &mut Context<Self>) {
-        if let Some(agent_diff) = self.agent_diff(cx) {
-            agent_diff.focus_handle(cx).focus(window);
+        if let Some(assistant_diff) = self.assistant_diff(cx) {
+            assistant_diff.focus_handle(cx).focus(window);
        }
        let action = action.boxed_clone();
        cx.defer(move |cx| {
@@ -818,19 +708,19 @@ impl AgentDiffToolbar {
    }
 }

-impl EventEmitter<ToolbarItemEvent> for AgentDiffToolbar {}
+impl EventEmitter<ToolbarItemEvent> for AssistantDiffToolbar {}

-impl ToolbarItemView for AgentDiffToolbar {
+impl ToolbarItemView for AssistantDiffToolbar {
    fn set_active_pane_item(
        &mut self,
        active_pane_item: Option<&dyn ItemHandle>,
        _: &mut Window,
        cx: &mut Context<Self>,
    ) -> ToolbarItemLocation {
-        self.agent_diff = active_pane_item
-            .and_then(|item| item.act_as::<AgentDiff>(cx))
+        self.assistant_diff = active_pane_item
+            .and_then(|item| item.act_as::<AssistantDiff>(cx))
            .map(|entity| entity.downgrade());
-        if self.agent_diff.is_some() {
+        if self.assistant_diff.is_some() {
            ToolbarItemLocation::PrimaryRight
        } else {
            ToolbarItemLocation::Hidden
@@ -846,14 +736,14 @@ impl ToolbarItemView for AgentDiffToolbar {
    }
 }

-impl Render for AgentDiffToolbar {
+impl Render for AssistantDiffToolbar {
    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let agent_diff = match self.agent_diff(cx) {
+        let assistant_diff = match self.assistant_diff(cx) {
            Some(ad) => ad,
            None => return div(),
        };

-        let is_empty = agent_diff.read(cx).multibuffer.read(cx).is_empty();
+        let is_empty = assistant_diff.read(cx).multibuffer.read(cx).is_empty();

        if is_empty {
            return div();
@@ -880,161 +770,3 @@ impl Render for AgentDiffToolbar {
            )
    }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{ThreadStore, thread_store};
-    use assistant_settings::AssistantSettings;
-    use context_server::ContextServerSettings;
-    use editor::EditorSettings;
-    use gpui::TestAppContext;
-    use project::{FakeFs, Project};
-    use prompt_store::PromptBuilder;
-    use serde_json::json;
-    use settings::{Settings, SettingsStore};
-    use std::sync::Arc;
-    use theme::ThemeSettings;
-    use util::path;
-
-    #[gpui::test]
-    async fn test_agent_diff(cx: &mut TestAppContext) {
-        cx.update(|cx| {
-            let settings_store = SettingsStore::test(cx);
-            cx.set_global(settings_store);
-            language::init(cx);
-            Project::init_settings(cx);
-            AssistantSettings::register(cx);
-            thread_store::init(cx);
-            workspace::init_settings(cx);
-            ThemeSettings::register(cx);
-            ContextServerSettings::register(cx);
-            EditorSettings::register(cx);
-        });
-
-        let fs = FakeFs::new(cx.executor());
-        fs.insert_tree(
-            path!("/test"),
-            json!({"file1": "abc\ndef\nghi\njkl\nmno\npqr\nstu\nvwx\nyz"}),
-        )
-        .await;
-        let project = Project::test(fs, [path!("/test").as_ref()], cx).await;
-        let buffer_path = project
-            .read_with(cx, |project, cx| {
-                project.find_project_path("test/file1", cx)
-            })
-            .unwrap();
-
-        let thread_store = cx.update(|cx| {
-            ThreadStore::new(
-                project.clone(),
-                Arc::default(),
-                Arc::new(PromptBuilder::new(None).unwrap()),
-                cx,
-            )
-            .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 (workspace, cx) =
-            cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
-        let agent_diff = cx.new_window_entity(|window, cx| {
-            AgentDiff::new(thread.clone(), workspace.downgrade(), window, cx)
-        });
-        let editor = agent_diff.read_with(cx, |diff, _cx| diff.editor.clone());
-
-        let buffer = project
-            .update(cx, |project, cx| project.open_buffer(buffer_path, cx))
-            .await
-            .unwrap();
-        cx.update(|_, cx| {
-            action_log.update(cx, |log, cx| log.buffer_read(buffer.clone(), cx));
-            buffer.update(cx, |buffer, cx| {
-                buffer
-                    .edit(
-                        [
-                            (Point::new(1, 1)..Point::new(1, 2), "E"),
-                            (Point::new(3, 2)..Point::new(3, 3), "L"),
-                            (Point::new(5, 0)..Point::new(5, 1), "P"),
-                            (Point::new(7, 1)..Point::new(7, 2), "W"),
-                        ],
-                        None,
-                        cx,
-                    )
-                    .unwrap()
-            });
-            action_log.update(cx, |log, cx| log.buffer_edited(buffer.clone(), cx));
-        });
-        cx.run_until_parked();
-
-        // When opening the assistant diff, the cursor is positioned on the first hunk.
-        assert_eq!(
-            editor.read_with(cx, |editor, cx| editor.text(cx)),
-            "abc\ndef\ndEf\nghi\njkl\njkL\nmno\npqr\nPqr\nstu\nvwx\nvWx\nyz"
-        );
-        assert_eq!(
-            editor
-                .update(cx, |editor, cx| editor.selections.newest::<Point>(cx))
-                .range(),
-            Point::new(1, 0)..Point::new(1, 0)
-        );
-
-        // After keeping a hunk, the cursor should be positioned on the second hunk.
-        agent_diff.update_in(cx, |diff, window, cx| diff.keep(&crate::Keep, window, cx));
-        cx.run_until_parked();
-        assert_eq!(
-            editor.read_with(cx, |editor, cx| editor.text(cx)),
-            "abc\ndEf\nghi\njkl\njkL\nmno\npqr\nPqr\nstu\nvwx\nvWx\nyz"
-        );
-        assert_eq!(
-            editor
-                .update(cx, |editor, cx| editor.selections.newest::<Point>(cx))
-                .range(),
-            Point::new(3, 0)..Point::new(3, 0)
-        );
-
-        // Rejecting a hunk also moves the cursor to the next hunk, possibly cycling if it's at the end.
-        editor.update_in(cx, |editor, window, cx| {
-            editor.change_selections(None, window, cx, |selections| {
-                selections.select_ranges([Point::new(10, 0)..Point::new(10, 0)])
-            });
-        });
-        agent_diff.update_in(cx, |diff, window, cx| {
-            diff.reject(&crate::Reject, window, cx)
-        });
-        cx.run_until_parked();
-        assert_eq!(
-            editor.read_with(cx, |editor, cx| editor.text(cx)),
-            "abc\ndEf\nghi\njkl\njkL\nmno\npqr\nPqr\nstu\nvwx\nyz"
-        );
-        assert_eq!(
-            editor
-                .update(cx, |editor, cx| editor.selections.newest::<Point>(cx))
-                .range(),
-            Point::new(3, 0)..Point::new(3, 0)
-        );
-
-        // Keeping a range that doesn't intersect the current selection doesn't move it.
-        agent_diff.update_in(cx, |diff, window, cx| {
-            let position = editor
-                .read(cx)
-                .buffer()
-                .read(cx)
-                .read(cx)
-                .anchor_before(Point::new(7, 0));
-            diff.keep_edits_in_ranges(vec![position..position], window, cx)
-        });
-        cx.run_until_parked();
-        assert_eq!(
-            editor.read_with(cx, |editor, cx| editor.text(cx)),
-            "abc\ndEf\nghi\njkl\njkL\nmno\nPqr\nstu\nvwx\nyz"
-        );
-        assert_eq!(
-            editor
-                .update(cx, |editor, cx| editor.selections.newest::<Point>(cx))
-                .range(),
-            Point::new(3, 0)..Point::new(3, 0)
-        );
-    }
-}
--- a/crates/assistant2/src/assistant_model_selector.rs
+++ b/crates/assistant2/src/assistant_model_selector.rs
@@ -9,17 +9,10 @@ use settings::update_settings_file;
 use std::sync::Arc;
 use ui::{ButtonLike, PopoverMenuHandle, Tooltip, prelude::*};

-#[derive(Clone, Copy)]
-pub enum ModelType {
-    Default,
-    InlineAssistant,
-}
-
 pub struct AssistantModelSelector {
    selector: Entity<LanguageModelSelector>,
    menu_handle: PopoverMenuHandle<LanguageModelSelector>,
    focus_handle: FocusHandle,
-    model_type: ModelType,
 }

 impl AssistantModelSelector {
@@ -27,7 +20,6 @@ impl AssistantModelSelector {
        fs: Arc<dyn Fs>,
        menu_handle: PopoverMenuHandle<LanguageModelSelector>,
        focus_handle: FocusHandle,
-        model_type: ModelType,
        window: &mut Window,
        cx: &mut App,
    ) -> Self {
@@ -36,32 +28,11 @@ impl AssistantModelSelector {
                let fs = fs.clone();
                LanguageModelSelector::new(
                    move |model, cx| {
-                        let provider = model.provider_id().0.to_string();
-                        let model_id = model.id().0.to_string();
-
-                        match model_type {
-                            ModelType::Default => {
-                                update_settings_file::<AssistantSettings>(
-                                    fs.clone(),
-                                    cx,
-                                    move |settings, _cx| {
-                                        settings.set_model(model.clone());
-                                    },
-                                );
-                            }
-                            ModelType::InlineAssistant => {
-                                update_settings_file::<AssistantSettings>(
-                                    fs.clone(),
-                                    cx,
-                                    move |settings, _cx| {
-                                        settings.set_inline_assistant_model(
-                                            provider.clone(),
-                                            model_id.clone(),
-                                        );
-                                    },
-                                );
-                            }
-                        }
+                        update_settings_file::<AssistantSettings>(
+                            fs.clone(),
+                            cx,
+                            move |settings, _cx| settings.set_model(model.clone()),
+                        );
                    },
                    window,
                    cx,
@@ -69,7 +40,6 @@ impl AssistantModelSelector {
            }),
            menu_handle,
            focus_handle,
-            model_type,
        }
    }

@@ -80,16 +50,10 @@ impl AssistantModelSelector {

 impl Render for AssistantModelSelector {
    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let model_registry = LanguageModelRegistry::read_global(cx);
-
-        let model = match self.model_type {
-            ModelType::Default => model_registry.default_model(),
-            ModelType::InlineAssistant => model_registry.inline_assistant_model(),
-        };
-
+        let active_model = LanguageModelRegistry::read_global(cx).active_model();
        let focus_handle = self.focus_handle.clone();
-        let model_name = match model {
-            Some(model) => model.model.name().0,
+        let model_name = match active_model {
+            Some(model) => model.name().0,
            _ => SharedString::from("No model selected"),
        };

--- a/crates/assistant2/src/assistant_panel.rs
+++ b/crates/assistant2/src/assistant_panel.rs
--- a/crates/assistant2/src/buffer_codegen.rs
+++ b/crates/assistant2/src/buffer_codegen.rs
@@ -156,9 +156,8 @@ impl BufferCodegen {
        }

        let primary_model = LanguageModelRegistry::read_global(cx)
-            .default_model()
-            .context("no active model")?
-            .model;
+            .active_model()
+            .context("no active model")?;

        for (model, alternative) in iter::once(primary_model)
            .chain(alternative_models)
--- a/crates/assistant2/src/context.rs
+++ b/crates/assistant2/src/context.rs
@@ -2,7 +2,7 @@ use std::{ops::Range, sync::Arc};

 use gpui::{App, Entity, SharedString};
 use language::{Buffer, File};
-use language_model::LanguageModelRequestMessage;
+use language_model::{LanguageModelRequestMessage, MessageContent};
 use project::ProjectPath;
 use serde::{Deserialize, Serialize};
 use text::{Anchor, BufferId};
@@ -19,6 +19,8 @@ impl ContextId {
        Self(post_inc(&mut self.0))
    }
 }
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ContextKind {
    File,
    Directory,
@@ -146,11 +148,11 @@ pub struct ContextSymbolId {
    pub range: Range<Anchor>,
 }

-/// Formats a collection of contexts into a string representation
-pub fn format_context_as_string<'a>(
+pub fn attach_context_to_message<'a>(
+    message: &mut LanguageModelRequestMessage,
    contexts: impl Iterator<Item = &'a AssistantContext>,
    cx: &App,
-) -> Option<String> {
+) {
    let mut file_context = Vec::new();
    let mut directory_context = Vec::new();
    let mut symbol_context = Vec::new();
@@ -167,78 +169,55 @@ pub fn format_context_as_string<'a>(
        }
    }

-    if file_context.is_empty()
-        && directory_context.is_empty()
-        && symbol_context.is_empty()
-        && fetch_context.is_empty()
-        && thread_context.is_empty()
-    {
-        return None;
-    }
-
-    let mut result = String::new();
-    result.push_str("\n<context>\n\
-        The following items were attached by the user. You don't need to use other tools to read them.\n\n");
+    let mut context_chunks = Vec::new();

    if !file_context.is_empty() {
-        result.push_str("<files>\n");
+        context_chunks.push("The following files are available:\n");
        for context in file_context {
-            result.push_str(&context.context_buffer.text);
+            context_chunks.push(&context.context_buffer.text);
        }
-        result.push_str("</files>\n");
    }

    if !directory_context.is_empty() {
-        result.push_str("<directories>\n");
+        context_chunks.push("The following directories are available:\n");
        for context in directory_context {
            for context_buffer in &context.context_buffers {
-                result.push_str(&context_buffer.text);
+                context_chunks.push(&context_buffer.text);
            }
        }
-        result.push_str("</directories>\n");
    }

    if !symbol_context.is_empty() {
-        result.push_str("<symbols>\n");
+        context_chunks.push("The following symbols are available:\n");
        for context in symbol_context {
-            result.push_str(&context.context_symbol.text);
-            result.push('\n');
+            context_chunks.push(&context.context_symbol.text);
        }
-        result.push_str("</symbols>\n");
    }

    if !fetch_context.is_empty() {
-        result.push_str("<fetched_urls>\n");
+        context_chunks.push("The following fetched results are available:\n");
        for context in &fetch_context {
-            result.push_str(&context.url);
-            result.push('\n');
-            result.push_str(&context.text);
-            result.push('\n');
+            context_chunks.push(&context.url);
+            context_chunks.push(&context.text);
        }
-        result.push_str("</fetched_urls>\n");
    }

+    // Need to own the SharedString for summary so that it can be referenced.
+    let mut thread_context_chunks = Vec::new();
    if !thread_context.is_empty() {
-        result.push_str("<conversation_threads>\n");
+        context_chunks.push("The following previous conversation threads are available:\n");
        for context in &thread_context {
-            result.push_str(&context.summary(cx));
-            result.push('\n');
-            result.push_str(&context.text);
-            result.push('\n');
+            thread_context_chunks.push(context.summary(cx));
+            thread_context_chunks.push(context.text.clone());
        }
-        result.push_str("</conversation_threads>\n");
+    }
+    for chunk in &thread_context_chunks {
+        context_chunks.push(chunk);
    }

-    result.push_str("</context>\n");
-    Some(result)
-}
-
-pub fn attach_context_to_message<'a>(
-    message: &mut LanguageModelRequestMessage,
-    contexts: impl Iterator<Item = &'a AssistantContext>,
-    cx: &App,
-) {
-    if let Some(context_string) = format_context_as_string(contexts, cx) {
-        message.content.push(context_string.into());
+    if !context_chunks.is_empty() {
+        message
+            .content
+            .push(MessageContent::Text(context_chunks.join("\n")));
    }
 }
--- a/crates/assistant2/src/context_picker.rs
+++ b/crates/assistant2/src/context_picker.rs
@@ -13,11 +13,10 @@ use editor::display_map::{Crease, FoldId};
 use editor::{Anchor, AnchorRangeExt as _, Editor, ExcerptId, FoldPlaceholder, ToOffset};
 use file_context_picker::render_file_context_entry;
 use gpui::{
-    App, DismissEvent, Empty, Entity, EventEmitter, FocusHandle, Focusable, Subscription, Task,
-    WeakEntity,
+    App, DismissEvent, Empty, Entity, EventEmitter, FocusHandle, Focusable, Task, WeakEntity,
 };
 use multi_buffer::MultiBufferRow;
-use project::{Entry, ProjectPath};
+use project::ProjectPath;
 use symbol_context_picker::SymbolContextPicker;
 use thread_context_picker::{ThreadContextEntry, render_thread_context_entry};
 use ui::{
@@ -31,7 +30,6 @@ use crate::context_picker::fetch_context_picker::FetchContextPicker;
 use crate::context_picker::file_context_picker::FileContextPicker;
 use crate::context_picker::thread_context_picker::ThreadContextPicker;
 use crate::context_store::ContextStore;
-use crate::thread::ThreadId;
 use crate::thread_store::ThreadStore;

 #[derive(Debug, Clone, Copy)]
@@ -77,7 +75,7 @@ impl ContextPickerMode {
            Self::File => "Files & Directories",
            Self::Symbol => "Symbols",
            Self::Fetch => "Fetch",
-            Self::Thread => "Threads",
+            Self::Thread => "Thread",
        }
    }

@@ -106,7 +104,6 @@ pub(super) struct ContextPicker {
    context_store: WeakEntity<ContextStore>,
    thread_store: Option<WeakEntity<ThreadStore>>,
    confirm_behavior: ConfirmBehavior,
-    _subscriptions: Vec<Subscription>,
 }

 impl ContextPicker {
@@ -118,22 +115,6 @@ impl ContextPicker {
        window: &mut Window,
        cx: &mut Context<Self>,
    ) -> Self {
-        let subscriptions = context_store
-            .upgrade()
-            .map(|context_store| {
-                cx.observe(&context_store, |this, _, cx| this.notify_current_picker(cx))
-            })
-            .into_iter()
-            .chain(
-                thread_store
-                    .as_ref()
-                    .and_then(|thread_store| thread_store.upgrade())
-                    .map(|thread_store| {
-                        cx.observe(&thread_store, |this, _, cx| this.notify_current_picker(cx))
-                    }),
-            )
-            .collect::<Vec<Subscription>>();
-
        ContextPicker {
            mode: ContextPickerState::Default(ContextMenu::build(
                window,
@@ -144,7 +125,6 @@ impl ContextPicker {
            context_store,
            thread_store,
            confirm_behavior,
-            _subscriptions: subscriptions,
        }
    }

@@ -379,25 +359,73 @@ impl ContextPicker {
    }

    fn recent_entries(&self, cx: &mut App) -> Vec<RecentEntry> {
-        let Some(workspace) = self.workspace.upgrade() else {
+        let Some(workspace) = self.workspace.upgrade().map(|w| w.read(cx)) else {
            return vec![];
        };

-        let Some(context_store) = self.context_store.upgrade() else {
+        let Some(context_store) = self.context_store.upgrade().map(|cs| cs.read(cx)) else {
            return vec![];
        };

-        recent_context_picker_entries(context_store, self.thread_store.clone(), workspace, cx)
-    }
+        let mut recent = Vec::with_capacity(6);

-    fn notify_current_picker(&mut self, cx: &mut Context<Self>) {
-        match &self.mode {
-            ContextPickerState::Default(entity) => entity.update(cx, |_, cx| cx.notify()),
-            ContextPickerState::File(entity) => entity.update(cx, |_, cx| cx.notify()),
-            ContextPickerState::Symbol(entity) => entity.update(cx, |_, cx| cx.notify()),
-            ContextPickerState::Fetch(entity) => entity.update(cx, |_, cx| cx.notify()),
-            ContextPickerState::Thread(entity) => entity.update(cx, |_, cx| cx.notify()),
+        let mut current_files = context_store.file_paths(cx);
+
+        if let Some(active_path) = active_singleton_buffer_path(&workspace, cx) {
+            current_files.insert(active_path);
        }
+
+        let project = workspace.project().read(cx);
+
+        recent.extend(
+            workspace
+                .recent_navigation_history_iter(cx)
+                .filter(|(path, _)| !current_files.contains(&path.path.to_path_buf()))
+                .take(4)
+                .filter_map(|(project_path, _)| {
+                    project
+                        .worktree_for_id(project_path.worktree_id, cx)
+                        .map(|worktree| RecentEntry::File {
+                            project_path,
+                            path_prefix: worktree.read(cx).root_name().into(),
+                        })
+                }),
+        );
+
+        let mut current_threads = context_store.thread_ids();
+
+        if let Some(active_thread) = workspace
+            .panel::<AssistantPanel>(cx)
+            .map(|panel| panel.read(cx).active_thread(cx))
+        {
+            current_threads.insert(active_thread.read(cx).id().clone());
+        }
+
+        let Some(thread_store) = self
+            .thread_store
+            .as_ref()
+            .and_then(|thread_store| thread_store.upgrade())
+        else {
+            return recent;
+        };
+
+        thread_store.update(cx, |thread_store, _cx| {
+            recent.extend(
+                thread_store
+                    .threads()
+                    .into_iter()
+                    .filter(|thread| !current_threads.contains(&thread.id))
+                    .take(2)
+                    .map(|thread| {
+                        RecentEntry::Thread(ThreadContextEntry {
+                            id: thread.id,
+                            summary: thread.summary,
+                        })
+                    }),
+            )
+        });
+
+        recent
    }
 }

@@ -451,6 +479,16 @@ fn supported_context_picker_modes(
    modes
 }

+fn active_singleton_buffer_path(workspace: &Workspace, cx: &App) -> Option<PathBuf> {
+    let active_item = workspace.active_item(cx)?;
+
+    let editor = active_item.to_any().downcast::<Editor>().ok()?.read(cx);
+    let buffer = editor.buffer().read(cx).as_singleton()?;
+
+    let path = buffer.read(cx).file()?.path().to_path_buf();
+    Some(path)
+}
+
 fn recent_context_picker_entries(
    context_store: Entity<ContextStore>,
    thread_store: Option<WeakEntity<ThreadStore>>,
@@ -459,8 +497,14 @@ fn recent_context_picker_entries(
 ) -> Vec<RecentEntry> {
    let mut recent = Vec::with_capacity(6);

-    let current_files = context_store.read(cx).file_paths(cx);
+    let mut current_files = context_store.read(cx).file_paths(cx);
+
    let workspace = workspace.read(cx);
+
+    if let Some(active_path) = active_singleton_buffer_path(workspace, cx) {
+        current_files.insert(active_path);
+    }
+
    let project = workspace.project().read(cx);

    recent.extend(
@@ -524,7 +568,6 @@ pub(crate) fn insert_crease_for_mention(
            return;
        };

-        let start = start.bias_right(&snapshot);
        let end = snapshot.anchor_before(start.to_offset(&snapshot) + content_len);

        let placeholder = FoldPlaceholder {
@@ -634,93 +677,3 @@ fn fold_toggle(
            .into_any_element()
    }
 }
-
-pub enum MentionLink {
-    File(ProjectPath, Entry),
-    Symbol(ProjectPath, String),
-    Fetch(String),
-    Thread(ThreadId),
-}
-
-impl MentionLink {
-    const FILE: &str = "@file";
-    const SYMBOL: &str = "@symbol";
-    const THREAD: &str = "@thread";
-    const FETCH: &str = "@fetch";
-
-    const SEPARATOR: &str = ":";
-
-    pub fn is_valid(url: &str) -> bool {
-        url.starts_with(Self::FILE)
-            || url.starts_with(Self::SYMBOL)
-            || url.starts_with(Self::FETCH)
-            || url.starts_with(Self::THREAD)
-    }
-
-    pub fn for_file(file_name: &str, full_path: &str) -> String {
-        format!("[@{}]({}:{})", file_name, Self::FILE, full_path)
-    }
-
-    pub fn for_symbol(symbol_name: &str, full_path: &str) -> String {
-        format!(
-            "[@{}]({}:{}:{})",
-            symbol_name,
-            Self::SYMBOL,
-            full_path,
-            symbol_name
-        )
-    }
-
-    pub fn for_fetch(url: &str) -> String {
-        format!("[@{}]({}:{})", url, Self::FETCH, url)
-    }
-
-    pub fn for_thread(thread: &ThreadContextEntry) -> String {
-        format!("[@{}]({}:{})", thread.summary, Self::THREAD, thread.id)
-    }
-
-    pub fn try_parse(link: &str, workspace: &Entity<Workspace>, cx: &App) -> Option<Self> {
-        fn extract_project_path_from_link(
-            path: &str,
-            workspace: &Entity<Workspace>,
-            cx: &App,
-        ) -> Option<ProjectPath> {
-            let path = PathBuf::from(path);
-            let worktree_name = path.iter().next()?;
-            let path: PathBuf = path.iter().skip(1).collect();
-            let worktree_id = workspace
-                .read(cx)
-                .visible_worktrees(cx)
-                .find(|worktree| worktree.read(cx).root_name() == worktree_name)
-                .map(|worktree| worktree.read(cx).id())?;
-            Some(ProjectPath {
-                worktree_id,
-                path: path.into(),
-            })
-        }
-
-        let (prefix, argument) = link.split_once(Self::SEPARATOR)?;
-        match prefix {
-            Self::FILE => {
-                let project_path = extract_project_path_from_link(argument, workspace, cx)?;
-                let entry = workspace
-                    .read(cx)
-                    .project()
-                    .read(cx)
-                    .entry_for_path(&project_path, cx)?;
-                Some(MentionLink::File(project_path, entry))
-            }
-            Self::SYMBOL => {
-                let (path, symbol) = argument.split_once(Self::SEPARATOR)?;
-                let project_path = extract_project_path_from_link(path, workspace, cx)?;
-                Some(MentionLink::Symbol(project_path, symbol.to_string()))
-            }
-            Self::THREAD => {
-                let thread_id = ThreadId::from(argument);
-                Some(MentionLink::Thread(thread_id))
-            }
-            Self::FETCH => Some(MentionLink::Fetch(argument.to_string())),
-            _ => None,
-        }
-    }
-}
--- a/crates/assistant2/src/context_picker/completion_provider.rs
+++ b/crates/assistant2/src/context_picker/completion_provider.rs
@@ -24,9 +24,7 @@ use crate::thread_store::ThreadStore;

 use super::fetch_context_picker::fetch_url_content;
 use super::thread_context_picker::ThreadContextEntry;
-use super::{
-    ContextPickerMode, MentionLink, recent_context_picker_entries, supported_context_picker_modes,
-};
+use super::{ContextPickerMode, recent_context_picker_entries, supported_context_picker_modes};

 pub struct ContextPickerCompletionProvider {
    workspace: WeakEntity<Workspace>,
@@ -156,7 +154,7 @@ impl ContextPickerCompletionProvider {
        } else {
            IconName::MessageBubbles
        };
-        let new_text = MentionLink::for_thread(&thread_entry);
+        let new_text = format!("@thread {}", thread_entry.summary);
        let new_text_len = new_text.len();
        Completion {
            old_range: source_range.clone(),
@@ -200,7 +198,7 @@ impl ContextPickerCompletionProvider {
        context_store: Entity<ContextStore>,
        http_client: Arc<HttpClientWithUrl>,
    ) -> Completion {
-        let new_text = MentionLink::for_fetch(&url_to_fetch);
+        let new_text = format!("@fetch {}", url_to_fetch);
        let new_text_len = new_text.len();
        Completion {
            old_range: source_range.clone(),
@@ -232,8 +230,8 @@ impl ContextPickerCompletionProvider {
                                url_to_fetch.to_string(),
                            ))
                            .await?;
-                        context_store.update(cx, |context_store, cx| {
-                            context_store.add_fetched_url(url_to_fetch.to_string(), content, cx)
+                        context_store.update(cx, |context_store, _| {
+                            context_store.add_fetched_url(url_to_fetch.to_string(), content)
                        })
                    })
                    .detach_and_log_err(cx);
@@ -281,7 +279,7 @@ impl ContextPickerCompletionProvider {
            crease_icon_path.clone()
        };

-        let new_text = MentionLink::for_file(&file_name, &full_path);
+        let new_text = format!("@file {}", full_path);
        let new_text_len = new_text.len();
        Completion {
            old_range: source_range.clone(),
@@ -328,22 +326,17 @@ impl ContextPickerCompletionProvider {
            .read(cx)
            .root_name();

-        let (file_name, directory) = super::file_context_picker::extract_file_name_and_directory(
+        let (file_name, _) = super::file_context_picker::extract_file_name_and_directory(
            &symbol.path.path,
            path_prefix,
        );
-        let full_path = if let Some(directory) = directory {
-            format!("{}{}", directory, file_name)
-        } else {
-            file_name.to_string()
-        };

        let comment_id = cx.theme().syntax().highlight_id("comment").map(HighlightId);
        let mut label = CodeLabel::plain(symbol.name.clone(), None);
        label.push_str(" ", None);
        label.push_str(&file_name, comment_id);

-        let new_text = MentionLink::for_symbol(&symbol.name, &full_path);
+        let new_text = format!("@symbol {}:{}", file_name, symbol.name);
        let new_text_len = new_text.len();
        Some(Completion {
            old_range: source_range.clone(),
@@ -407,7 +400,7 @@ impl CompletionProvider for ContextPickerCompletionProvider {
        };

        let snapshot = buffer.read(cx).snapshot();
-        let source_range = snapshot.anchor_before(state.source_range.start)
+        let source_range = snapshot.anchor_after(state.source_range.start)
            ..snapshot.anchor_before(state.source_range.end);

        let thread_store = self.thread_store.clone();
@@ -653,15 +646,6 @@ impl MentionCompletion {
        if last_mention_start >= line.len() {
            return Some(Self::default());
        }
-        if last_mention_start > 0
-            && line
-                .chars()
-                .nth(last_mention_start - 1)
-                .map_or(false, |c| !c.is_whitespace())
-        {
-            return None;
-        }
-
        let rest_of_line = &line[last_mention_start + 1..];

        let mut mode = None;
@@ -762,8 +746,6 @@ mod tests {
                argument: Some("main.rs".to_string()),
            })
        );
-
-        assert_eq!(MentionCompletion::try_parse("test@", 0), None);
    }

    #[gpui::test]
@@ -862,7 +844,7 @@ mod tests {
                .expect("Opened test file wasn't an editor")
        });

-        let context_store = cx.new(|_| ContextStore::new(workspace.downgrade(), None));
+        let context_store = cx.new(|_| ContextStore::new(workspace.downgrade()));

        let editor_entity = editor.downgrade();
        editor.update_in(&mut cx, |editor, window, cx| {
@@ -890,10 +872,10 @@ mod tests {
            assert_eq!(
                current_completion_labels(editor),
                &[
-                    "editor dir/",
                    "seven.txt dir/b/",
                    "six.txt dir/b/",
                    "five.txt dir/b/",
+                    "four.txt dir/a/",
                    "Files & Directories",
                    "Symbols",
                    "Fetch"
@@ -932,50 +914,44 @@ mod tests {
        });

        editor.update(&mut cx, |editor, cx| {
-            assert_eq!(editor.text(cx), "Lorem [@one.txt](@file:dir/a/one.txt)",);
+            assert_eq!(editor.text(cx), "Lorem @file dir/a/one.txt",);
            assert!(!editor.has_visible_completions_menu());
            assert_eq!(
                crease_ranges(editor, cx),
-                vec![Point::new(0, 6)..Point::new(0, 37)]
+                vec![Point::new(0, 6)..Point::new(0, 25)]
            );
        });

        cx.simulate_input(" ");

        editor.update(&mut cx, |editor, cx| {
-            assert_eq!(editor.text(cx), "Lorem [@one.txt](@file:dir/a/one.txt) ",);
+            assert_eq!(editor.text(cx), "Lorem @file dir/a/one.txt ",);
            assert!(!editor.has_visible_completions_menu());
            assert_eq!(
                crease_ranges(editor, cx),
-                vec![Point::new(0, 6)..Point::new(0, 37)]
+                vec![Point::new(0, 6)..Point::new(0, 25)]
            );
        });

        cx.simulate_input("Ipsum ");

        editor.update(&mut cx, |editor, cx| {
-            assert_eq!(
-                editor.text(cx),
-                "Lorem [@one.txt](@file:dir/a/one.txt) Ipsum ",
-            );
+            assert_eq!(editor.text(cx), "Lorem @file dir/a/one.txt Ipsum ",);
            assert!(!editor.has_visible_completions_menu());
            assert_eq!(
                crease_ranges(editor, cx),
-                vec![Point::new(0, 6)..Point::new(0, 37)]
+                vec![Point::new(0, 6)..Point::new(0, 25)]
            );
        });

        cx.simulate_input("@file ");

        editor.update(&mut cx, |editor, cx| {
-            assert_eq!(
-                editor.text(cx),
-                "Lorem [@one.txt](@file:dir/a/one.txt) Ipsum @file ",
-            );
+            assert_eq!(editor.text(cx), "Lorem @file dir/a/one.txt Ipsum @file ",);
            assert!(editor.has_visible_completions_menu());
            assert_eq!(
                crease_ranges(editor, cx),
-                vec![Point::new(0, 6)..Point::new(0, 37)]
+                vec![Point::new(0, 6)..Point::new(0, 25)]
            );
        });

@@ -988,14 +964,14 @@ mod tests {
        editor.update(&mut cx, |editor, cx| {
            assert_eq!(
                editor.text(cx),
-                "Lorem [@one.txt](@file:dir/a/one.txt) Ipsum [@editor](@file:dir/editor)"
+                "Lorem @file dir/a/one.txt Ipsum @file dir/b/seven.txt"
            );
            assert!(!editor.has_visible_completions_menu());
            assert_eq!(
                crease_ranges(editor, cx),
                vec![
-                    Point::new(0, 6)..Point::new(0, 37),
-                    Point::new(0, 44)..Point::new(0, 71)
+                    Point::new(0, 6)..Point::new(0, 25),
+                    Point::new(0, 32)..Point::new(0, 53)
                ]
            );
        });
@@ -1005,14 +981,14 @@ mod tests {
        editor.update(&mut cx, |editor, cx| {
            assert_eq!(
                editor.text(cx),
-                "Lorem [@one.txt](@file:dir/a/one.txt) Ipsum [@editor](@file:dir/editor)\n@"
+                "Lorem @file dir/a/one.txt Ipsum @file dir/b/seven.txt\n@"
            );
            assert!(editor.has_visible_completions_menu());
            assert_eq!(
                crease_ranges(editor, cx),
                vec![
-                    Point::new(0, 6)..Point::new(0, 37),
-                    Point::new(0, 44)..Point::new(0, 71)
+                    Point::new(0, 6)..Point::new(0, 25),
+                    Point::new(0, 32)..Point::new(0, 53)
                ]
            );
        });
@@ -1026,15 +1002,15 @@ mod tests {
        editor.update(&mut cx, |editor, cx| {
            assert_eq!(
                editor.text(cx),
-                "Lorem [@one.txt](@file:dir/a/one.txt) Ipsum [@editor](@file:dir/editor)\n[@seven.txt](@file:dir/b/seven.txt)"
+                "Lorem @file dir/a/one.txt Ipsum @file dir/b/seven.txt\n@file dir/b/six.txt"
            );
            assert!(!editor.has_visible_completions_menu());
            assert_eq!(
                crease_ranges(editor, cx),
                vec![
-                    Point::new(0, 6)..Point::new(0, 37),
-                    Point::new(0, 44)..Point::new(0, 71),
-                    Point::new(1, 0)..Point::new(1, 35)
+                    Point::new(0, 6)..Point::new(0, 25),
+                    Point::new(0, 32)..Point::new(0, 53),
+                    Point::new(1, 0)..Point::new(1, 19)
                ]
            );
        });
--- a/crates/assistant2/src/context_picker/fetch_context_picker.rs
+++ b/crates/assistant2/src/context_picker/fetch_context_picker.rs
@@ -213,8 +213,8 @@ impl PickerDelegate for FetchContextPickerDelegate {
            this.update_in(cx, |this, window, cx| {
                this.delegate
                    .context_store
-                    .update(cx, |context_store, cx| {
-                        context_store.add_fetched_url(url, text, cx)
+                    .update(cx, |context_store, _cx| {
+                        context_store.add_fetched_url(url, text);
                    })?;

                match confirm_behavior {
--- a/crates/assistant2/src/context_picker/file_context_picker.rs
+++ b/crates/assistant2/src/context_picker/file_context_picker.rs
--- a/crates/assistant2/src/context_picker/symbol_context_picker.rs
+++ b/crates/assistant2/src/context_picker/symbol_context_picker.rs
--- a/crates/assistant2/src/context_picker/thread_context_picker.rs
+++ b/crates/assistant2/src/context_picker/thread_context_picker.rs
--- a/crates/assistant2/src/context_store.rs
+++ b/crates/assistant2/src/context_store.rs
@@ -4,17 +4,15 @@ use std::sync::Arc;

 use anyhow::{Context as _, Result, anyhow};
 use collections::{BTreeMap, HashMap, HashSet};
-use futures::future::join_all;
 use futures::{self, Future, FutureExt, future};
-use gpui::{App, AppContext as _, Context, Entity, SharedString, Task, WeakEntity};
+use gpui::{App, AppContext as _, AsyncApp, Context, Entity, SharedString, Task, WeakEntity};
 use language::{Buffer, File};
 use project::{ProjectItem, ProjectPath, Worktree};
 use rope::Rope;
 use text::{Anchor, BufferId, OffsetRangeExt};
-use util::{ResultExt as _, maybe};
+use util::{ResultExt, maybe};
 use workspace::Workspace;

-use crate::ThreadStore;
 use crate::context::{
    AssistantContext, ContextBuffer, ContextId, ContextSymbol, ContextSymbolId, DirectoryContext,
    FetchedUrlContext, FileContext, SymbolContext, ThreadContext,
@@ -25,7 +23,6 @@ use crate::thread::{Thread, ThreadId};
 pub struct ContextStore {
    workspace: WeakEntity<Workspace>,
    context: Vec<AssistantContext>,
-    thread_store: Option<WeakEntity<ThreadStore>>,
    // TODO: If an EntityId is used for all context types (like BufferId), can remove ContextId.
    next_context_id: ContextId,
    files: BTreeMap<BufferId, ContextId>,
@@ -34,18 +31,13 @@ pub struct ContextStore {
    symbol_buffers: HashMap<ContextSymbolId, Entity<Buffer>>,
    symbols_by_path: HashMap<ProjectPath, Vec<ContextSymbolId>>,
    threads: HashMap<ThreadId, ContextId>,
-    thread_summary_tasks: Vec<Task<()>>,
    fetched_urls: HashMap<String, ContextId>,
 }

 impl ContextStore {
-    pub fn new(
-        workspace: WeakEntity<Workspace>,
-        thread_store: Option<WeakEntity<ThreadStore>>,
-    ) -> Self {
+    pub fn new(workspace: WeakEntity<Workspace>) -> Self {
        Self {
            workspace,
-            thread_store,
            context: Vec::new(),
            next_context_id: ContextId(0),
            files: BTreeMap::default(),
@@ -54,7 +46,6 @@ impl ContextStore {
            symbol_buffers: HashMap::default(),
            symbols_by_path: HashMap::default(),
            threads: HashMap::default(),
-            thread_summary_tasks: Vec::new(),
            fetched_urls: HashMap::default(),
        }
    }
@@ -95,14 +86,14 @@ impl ContextStore {
                project.open_buffer(project_path.clone(), cx)
            })?;

-            let buffer = open_buffer_task.await?;
-            let buffer_id = this.update(cx, |_, cx| buffer.read(cx).remote_id())?;
+            let buffer_entity = open_buffer_task.await?;
+            let buffer_id = this.update(cx, |_, cx| buffer_entity.read(cx).remote_id())?;

-            let already_included = this.update(cx, |this, cx| {
+            let already_included = this.update(cx, |this, _cx| {
                match this.will_include_buffer(buffer_id, &project_path.path) {
                    Some(FileInclusion::Direct(context_id)) => {
                        if remove_if_exists {
-                            this.remove_context(context_id, cx);
+                            this.remove_context(context_id);
                        }
                        true
                    }
@@ -115,13 +106,21 @@ impl ContextStore {
                return anyhow::Ok(());
            }

-            let (buffer_info, text_task) =
-                this.update(cx, |_, cx| collect_buffer_info_and_text(buffer, None, cx))??;
+            let (buffer_info, text_task) = this.update(cx, |_, cx| {
+                let buffer = buffer_entity.read(cx);
+                collect_buffer_info_and_text(
+                    project_path.path.clone(),
+                    buffer_entity,
+                    buffer,
+                    None,
+                    cx.to_async(),
+                )
+            })??;

            let text = text_task.await;

-            this.update(cx, |this, cx| {
-                this.insert_file(make_context_buffer(buffer_info, text), cx);
+            this.update(cx, |this, _cx| {
+                this.insert_file(make_context_buffer(buffer_info, text));
            })?;

            anyhow::Ok(())
@@ -130,29 +129,41 @@ impl ContextStore {

    pub fn add_file_from_buffer(
        &mut self,
-        buffer: Entity<Buffer>,
+        buffer_entity: Entity<Buffer>,
        cx: &mut Context<Self>,
    ) -> Task<Result<()>> {
        cx.spawn(async move |this, cx| {
-            let (buffer_info, text_task) =
-                this.update(cx, |_, cx| collect_buffer_info_and_text(buffer, None, cx))??;
+            let (buffer_info, text_task) = this.update(cx, |_, cx| {
+                let buffer = buffer_entity.read(cx);
+                let Some(file) = buffer.file() else {
+                    return Err(anyhow!("Buffer has no path."));
+                };
+                collect_buffer_info_and_text(
+                    file.path().clone(),
+                    buffer_entity,
+                    buffer,
+                    None,
+                    cx.to_async(),
+                )
+            })??;

            let text = text_task.await;

-            this.update(cx, |this, cx| {
-                this.insert_file(make_context_buffer(buffer_info, text), cx)
+            this.update(cx, |this, _cx| {
+                this.insert_file(make_context_buffer(buffer_info, text))
            })?;

            anyhow::Ok(())
        })
    }

-    fn insert_file(&mut self, context_buffer: ContextBuffer, cx: &mut Context<Self>) {
+    fn insert_file(&mut self, context_buffer: ContextBuffer) {
        let id = self.next_context_id.post_inc();
        self.files.insert(context_buffer.id, id);
-        self.context
-            .push(AssistantContext::File(FileContext { id, context_buffer }));
-        cx.notify();
+        self.context.push(AssistantContext::File(FileContext {
+            id,
+            context_buffer: context_buffer,
+        }));
    }

    pub fn add_directory(
@@ -172,7 +183,7 @@ impl ContextStore {
        let already_included = match self.includes_directory(&project_path.path) {
            Some(FileInclusion::Direct(context_id)) => {
                if remove_if_exists {
-                    self.remove_context(context_id, cx);
+                    self.remove_context(context_id);
                }
                true
            }
@@ -213,13 +224,22 @@ impl ContextStore {
            let mut buffer_infos = Vec::new();
            let mut text_tasks = Vec::new();
            this.update(cx, |_, cx| {
-                // Skip all binary files and other non-UTF8 files
-                for buffer in buffers.into_iter().flatten() {
-                    if let Some((buffer_info, text_task)) =
-                        collect_buffer_info_and_text(buffer, None, cx).log_err()
-                    {
-                        buffer_infos.push(buffer_info);
-                        text_tasks.push(text_task);
+                for (path, buffer_entity) in files.into_iter().zip(buffers) {
+                    // Skip all binary files and other non-UTF8 files
+                    if let Ok(buffer_entity) = buffer_entity {
+                        let buffer = buffer_entity.read(cx);
+                        if let Some((buffer_info, text_task)) = collect_buffer_info_and_text(
+                            path,
+                            buffer_entity,
+                            buffer,
+                            None,
+                            cx.to_async(),
+                        )
+                        .log_err()
+                        {
+                            buffer_infos.push(buffer_info);
+                            text_tasks.push(text_task);
+                        }
                    }
                }
                anyhow::Ok(())
@@ -239,20 +259,15 @@ impl ContextStore {
                ));
            }

-            this.update(cx, |this, cx| {
-                this.insert_directory(project_path, context_buffers, cx);
+            this.update(cx, |this, _| {
+                this.insert_directory(project_path, context_buffers);
            })?;

            anyhow::Ok(())
        })
    }

-    fn insert_directory(
-        &mut self,
-        project_path: ProjectPath,
-        context_buffers: Vec<ContextBuffer>,
-        cx: &mut Context<Self>,
-    ) {
+    fn insert_directory(&mut self, project_path: ProjectPath, context_buffers: Vec<ContextBuffer>) {
        let id = self.next_context_id.post_inc();
        self.directories.insert(project_path.path.to_path_buf(), id);

@@ -262,7 +277,6 @@ impl ContextStore {
                project_path,
                context_buffers,
            }));
-        cx.notify();
    }

    pub fn add_symbol(
@@ -275,8 +289,12 @@ impl ContextStore {
        cx: &mut Context<Self>,
    ) -> Task<Result<bool>> {
        let buffer_ref = buffer.read(cx);
+        let Some(file) = buffer_ref.file() else {
+            return Task::ready(Err(anyhow!("Buffer has no path.")));
+        };
+
        let Some(project_path) = buffer_ref.project_path(cx) else {
-            return Task::ready(Err(anyhow!("buffer has no path")));
+            return Task::ready(Err(anyhow!("Buffer has no project path.")));
        };

        if let Some(symbols_for_path) = self.symbols_by_path.get(&project_path) {
@@ -293,39 +311,41 @@ impl ContextStore {

            if let Some(id) = matching_symbol_id {
                if remove_if_exists {
-                    self.remove_context(id, cx);
+                    self.remove_context(id);
                }
                return Task::ready(Ok(false));
            }
        }

-        let (buffer_info, collect_content_task) =
-            match collect_buffer_info_and_text(buffer, Some(symbol_enclosing_range.clone()), cx) {
-                Ok((buffer_info, collect_context_task)) => (buffer_info, collect_context_task),
-                Err(err) => return Task::ready(Err(err)),
-            };
+        let (buffer_info, collect_content_task) = match collect_buffer_info_and_text(
+            file.path().clone(),
+            buffer,
+            buffer_ref,
+            Some(symbol_enclosing_range.clone()),
+            cx.to_async(),
+        ) {
+            Ok((buffer_info, collect_context_task)) => (buffer_info, collect_context_task),
+            Err(err) => return Task::ready(Err(err)),
+        };

        cx.spawn(async move |this, cx| {
            let content = collect_content_task.await;

-            this.update(cx, |this, cx| {
-                this.insert_symbol(
-                    make_context_symbol(
-                        buffer_info,
-                        project_path,
-                        symbol_name,
-                        symbol_range,
-                        symbol_enclosing_range,
-                        content,
-                    ),
-                    cx,
-                )
+            this.update(cx, |this, _cx| {
+                this.insert_symbol(make_context_symbol(
+                    buffer_info,
+                    project_path,
+                    symbol_name,
+                    symbol_range,
+                    symbol_enclosing_range,
+                    content,
+                ))
            })?;
            anyhow::Ok(true)
        })
    }

-    fn insert_symbol(&mut self, context_symbol: ContextSymbol, cx: &mut Context<Self>) {
+    fn insert_symbol(&mut self, context_symbol: ContextSymbol) {
        let id = self.next_context_id.post_inc();
        self.symbols.insert(context_symbol.id.clone(), id);
        self.symbols_by_path
@@ -338,7 +358,6 @@ impl ContextStore {
            id,
            context_symbol,
        }));
-        cx.notify();
    }

    pub fn add_thread(
@@ -349,70 +368,29 @@ impl ContextStore {
    ) {
        if let Some(context_id) = self.includes_thread(&thread.read(cx).id()) {
            if remove_if_exists {
-                self.remove_context(context_id, cx);
+                self.remove_context(context_id);
            }
        } else {
            self.insert_thread(thread, cx);
        }
    }

-    pub fn wait_for_summaries(&mut self, cx: &App) -> Task<()> {
-        let tasks = std::mem::take(&mut self.thread_summary_tasks);
-
-        cx.spawn(async move |_cx| {
-            join_all(tasks).await;
-        })
-    }
-
-    fn insert_thread(&mut self, thread: Entity<Thread>, cx: &mut Context<Self>) {
-        if let Some(summary_task) =
-            thread.update(cx, |thread, cx| thread.generate_detailed_summary(cx))
-        {
-            let thread = thread.clone();
-            let thread_store = self.thread_store.clone();
-
-            self.thread_summary_tasks.push(cx.spawn(async move |_, cx| {
-                summary_task.await;
-
-                if let Some(thread_store) = thread_store {
-                    // Save thread so its summary can be reused later
-                    let save_task = thread_store
-                        .update(cx, |thread_store, cx| thread_store.save_thread(&thread, cx));
-
-                    if let Some(save_task) = save_task.ok() {
-                        save_task.await.log_err();
-                    }
-                }
-            }));
-        }
-
+    fn insert_thread(&mut self, thread: Entity<Thread>, cx: &App) {
        let id = self.next_context_id.post_inc();
-
-        let text = thread.read(cx).latest_detailed_summary_or_text();
+        let text = thread.read(cx).text().into();

        self.threads.insert(thread.read(cx).id().clone(), id);
        self.context
            .push(AssistantContext::Thread(ThreadContext { id, thread, text }));
-        cx.notify();
    }

-    pub fn add_fetched_url(
-        &mut self,
-        url: String,
-        text: impl Into<SharedString>,
-        cx: &mut Context<ContextStore>,
-    ) {
+    pub fn add_fetched_url(&mut self, url: String, text: impl Into<SharedString>) {
        if self.includes_url(&url).is_none() {
-            self.insert_fetched_url(url, text, cx);
+            self.insert_fetched_url(url, text);
        }
    }

-    fn insert_fetched_url(
-        &mut self,
-        url: String,
-        text: impl Into<SharedString>,
-        cx: &mut Context<ContextStore>,
-    ) {
+    fn insert_fetched_url(&mut self, url: String, text: impl Into<SharedString>) {
        let id = self.next_context_id.post_inc();

        self.fetched_urls.insert(url.clone(), id);
@@ -422,7 +400,6 @@ impl ContextStore {
                url: url.into(),
                text: text.into(),
            }));
-        cx.notify();
    }

    pub fn accept_suggested_context(
@@ -449,7 +426,7 @@ impl ContextStore {
        Task::ready(Ok(()))
    }

-    pub fn remove_context(&mut self, id: ContextId, cx: &mut Context<Self>) {
+    pub fn remove_context(&mut self, id: ContextId) {
        let Some(ix) = self.context.iter().position(|context| context.id() == id) else {
            return;
        };
@@ -481,8 +458,6 @@ impl ContextStore {
                self.threads.retain(|_, context_id| *context_id != id);
            }
        }
-
-        cx.notify();
    }

    /// Returns whether the buffer is already included directly in the context, or if it will be
@@ -602,16 +577,16 @@ pub enum FileInclusion {

 // ContextBuffer without text.
 struct BufferInfo {
-    id: BufferId,
-    buffer: Entity<Buffer>,
+    buffer_entity: Entity<Buffer>,
    file: Arc<dyn File>,
+    id: BufferId,
    version: clock::Global,
 }

 fn make_context_buffer(info: BufferInfo, text: SharedString) -> ContextBuffer {
    ContextBuffer {
        id: info.id,
-        buffer: info.buffer,
+        buffer: info.buffer_entity,
        file: info.file,
        version: info.version,
        text,
@@ -630,37 +605,34 @@ fn make_context_symbol(
        id: ContextSymbolId { name, range, path },
        buffer_version: info.version,
        enclosing_range,
-        buffer: info.buffer,
+        buffer: info.buffer_entity,
        text,
    }
 }

 fn collect_buffer_info_and_text(
-    buffer: Entity<Buffer>,
+    path: Arc<Path>,
+    buffer_entity: Entity<Buffer>,
+    buffer: &Buffer,
    range: Option<Range<Anchor>>,
-    cx: &App,
+    cx: AsyncApp,
 ) -> Result<(BufferInfo, Task<SharedString>)> {
-    let buffer_ref = buffer.read(cx);
-    let file = buffer_ref.file().context("file context must have a path")?;
-
-    // Important to collect version at the same time as content so that staleness logic is correct.
-    let version = buffer_ref.version();
-    let content = if let Some(range) = range {
-        buffer_ref.text_for_range(range).collect::<Rope>()
-    } else {
-        buffer_ref.as_rope().clone()
-    };
-
    let buffer_info = BufferInfo {
-        buffer,
-        id: buffer_ref.remote_id(),
-        file: file.clone(),
-        version,
+        id: buffer.remote_id(),
+        buffer_entity,
+        file: buffer
+            .file()
+            .context("buffer context must have a file")?
+            .clone(),
+        version: buffer.version(),
    };
-
-    let full_path = file.full_path(cx);
-    let text_task = cx.background_spawn(async move { to_fenced_codeblock(&full_path, content) });
-
+    // Important to collect version at the same time as content so that staleness logic is correct.
+    let content = if let Some(range) = range {
+        buffer.text_for_range(range).collect::<Rope>()
+    } else {
+        buffer.as_rope().clone()
+    };
+    let text_task = cx.background_spawn(async move { to_fenced_codeblock(&path, content) });
    Ok((buffer_info, text_task))
 }

@@ -893,7 +865,7 @@ fn refresh_thread_text(
    cx.spawn(async move |cx| {
        context_store
            .update(cx, |context_store, cx| {
-                let text = thread.read(cx).latest_detailed_summary_or_text();
+                let text = thread.read(cx).text().into();
                context_store.replace_context(AssistantContext::Thread(ThreadContext {
                    id,
                    thread,
@@ -909,9 +881,16 @@ fn refresh_context_buffer(
    cx: &App,
 ) -> Option<impl Future<Output = ContextBuffer> + use<>> {
    let buffer = context_buffer.buffer.read(cx);
+    let path = buffer_path_log_err(buffer, cx)?;
    if buffer.version.changed_since(&context_buffer.version) {
-        let (buffer_info, text_task) =
-            collect_buffer_info_and_text(context_buffer.buffer.clone(), None, cx).log_err()?;
+        let (buffer_info, text_task) = collect_buffer_info_and_text(
+            path,
+            context_buffer.buffer.clone(),
+            buffer,
+            None,
+            cx.to_async(),
+        )
+        .log_err()?;
        Some(text_task.map(move |text| make_context_buffer(buffer_info, text)))
    } else {
        None
@@ -923,12 +902,15 @@ fn refresh_context_symbol(
    cx: &App,
 ) -> Option<impl Future<Output = ContextSymbol> + use<>> {
    let buffer = context_symbol.buffer.read(cx);
+    let path = buffer_path_log_err(buffer, cx)?;
    let project_path = buffer.project_path(cx)?;
    if buffer.version.changed_since(&context_symbol.buffer_version) {
        let (buffer_info, text_task) = collect_buffer_info_and_text(
+            path,
            context_symbol.buffer.clone(),
+            buffer,
            Some(context_symbol.enclosing_range.clone()),
-            cx,
+            cx.to_async(),
        )
        .log_err()?;
        let name = context_symbol.id.name.clone();
--- a/crates/assistant2/src/context_strip.rs
+++ b/crates/assistant2/src/context_strip.rs
@@ -59,7 +59,6 @@ impl ContextStrip {
        let focus_handle = cx.focus_handle();

        let subscriptions = vec![
-            cx.observe(&context_store, |_, _, cx| cx.notify()),
            cx.subscribe_in(&context_picker, window, Self::handle_context_picker_event),
            cx.on_focus(&focus_handle, window, Self::handle_focus),
            cx.on_blur(&focus_handle, window, Self::handle_blur),
@@ -291,9 +290,9 @@ impl ContextStrip {
        if let Some(index) = self.focused_index {
            let mut is_empty = false;

-            self.context_store.update(cx, |this, cx| {
+            self.context_store.update(cx, |this, _cx| {
                if let Some(item) = this.context().get(index) {
-                    this.remove_context(item.id(), cx);
+                    this.remove_context(item.id());
                }

                is_empty = this.context().is_empty();
@@ -476,8 +475,8 @@ impl Render for ContextStrip {
                            Some({
                                let context_store = self.context_store.clone();
                                Rc::new(cx.listener(move |_this, _event, _window, cx| {
-                                    context_store.update(cx, |this, cx| {
-                                        this.remove_context(id, cx);
+                                    context_store.update(cx, |this, _cx| {
+                                        this.remove_context(id);
                                    });
                                    cx.notify();
                                }))
--- a/crates/assistant2/src/history_store.rs
+++ b/crates/assistant2/src/history_store.rs
@@ -4,7 +4,6 @@ use gpui::{Entity, prelude::*};

 use crate::thread_store::{SerializedThreadMetadata, ThreadStore};

-#[derive(Debug)]
 pub enum HistoryEntry {
    Thread(SerializedThreadMetadata),
    Context(SavedContextMetadata),
@@ -22,27 +21,25 @@ impl HistoryEntry {
 pub struct HistoryStore {
    thread_store: Entity<ThreadStore>,
    context_store: Entity<assistant_context_editor::ContextStore>,
-    _subscriptions: Vec<gpui::Subscription>,
 }

 impl HistoryStore {
    pub fn new(
        thread_store: Entity<ThreadStore>,
        context_store: Entity<assistant_context_editor::ContextStore>,
-        cx: &mut Context<Self>,
+        _cx: &mut Context<Self>,
    ) -> Self {
-        let subscriptions = vec![
-            cx.observe(&thread_store, |_, _, cx| cx.notify()),
-            cx.observe(&context_store, |_, _, cx| cx.notify()),
-        ];
-
        Self {
            thread_store,
            context_store,
-            _subscriptions: subscriptions,
        }
    }

+    /// Returns the number of history entries.
+    pub fn entry_count(&self, cx: &mut Context<Self>) -> usize {
+        self.entries(cx).len()
+    }
+
    pub fn entries(&self, cx: &mut Context<Self>) -> Vec<HistoryEntry> {
        let mut history_entries = Vec::new();

--- a/crates/assistant2/src/inline_assistant.rs
+++ b/crates/assistant2/src/inline_assistant.rs
@@ -37,8 +37,8 @@ use text::{OffsetRangeExt, ToPoint as _};
 use ui::prelude::*;
 use util::RangeExt;
 use util::ResultExt;
-use workspace::{ItemHandle, Toast, Workspace, dock::Panel, notifications::NotificationId};
-use zed_actions::agent::OpenConfiguration;
+use workspace::{ItemHandle, Toast, Workspace, notifications::NotificationId};
+use workspace::{ShowConfiguration, dock::Panel};

 use crate::AssistantPanel;
 use crate::buffer_codegen::{BufferCodegen, CodegenAlternative, CodegenEvent};
@@ -239,8 +239,8 @@ impl InlineAssistant {

        let is_authenticated = || {
            LanguageModelRegistry::read_global(cx)
-                .inline_assistant_model()
-                .map_or(false, |model| model.provider.is_authenticated(cx))
+                .active_provider()
+                .map_or(false, |provider| provider.is_authenticated(cx))
        };

        let thread_store = workspace
@@ -279,8 +279,8 @@ impl InlineAssistant {
            cx.spawn_in(window, async move |_workspace, cx| {
                let Some(task) = cx.update(|_, cx| {
                    LanguageModelRegistry::read_global(cx)
-                        .inline_assistant_model()
-                        .map_or(None, |model| Some(model.provider.authenticate(cx)))
+                        .active_provider()
+                        .map_or(None, |provider| Some(provider.authenticate(cx)))
                })?
                else {
                    let answer = cx
@@ -295,7 +295,7 @@ impl InlineAssistant {
                    if let Some(answer) = answer {
                        if answer == 0 {
                            cx.update(|window, cx| {
-                                window.dispatch_action(Box::new(OpenConfiguration), cx)
+                                window.dispatch_action(Box::new(ShowConfiguration), cx)
                            })
                            .ok();
                        }
@@ -401,14 +401,14 @@ impl InlineAssistant {

            codegen_ranges.push(anchor_range);

-            if let Some(model) = LanguageModelRegistry::read_global(cx).inline_assistant_model() {
+            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
                self.telemetry.report_assistant_event(AssistantEvent {
                    conversation_id: None,
                    kind: AssistantKind::Inline,
                    phase: AssistantPhase::Invoked,
                    message_id: None,
-                    model: model.model.telemetry_id(),
-                    model_provider: model.provider.id().to_string(),
+                    model: model.telemetry_id(),
+                    model_provider: model.provider_id().to_string(),
                    response_latency: None,
                    error_message: None,
                    language_name: buffer.language().map(|language| language.name().to_proto()),
@@ -424,8 +424,7 @@ impl InlineAssistant {
        let mut assist_to_focus = None;
        for range in codegen_ranges {
            let assist_id = self.next_assist_id.post_inc();
-            let context_store =
-                cx.new(|_cx| ContextStore::new(workspace.clone(), thread_store.clone()));
+            let context_store = cx.new(|_cx| ContextStore::new(workspace.clone()));
            let codegen = cx.new(|cx| {
                BufferCodegen::new(
                    editor.read(cx).buffer().clone(),
@@ -537,8 +536,7 @@ impl InlineAssistant {
            range.end = range.end.bias_right(&snapshot);
        }

-        let context_store =
-            cx.new(|_cx| ContextStore::new(workspace.clone(), thread_store.clone()));
+        let context_store = cx.new(|_cx| ContextStore::new(workspace.clone()));

        let codegen = cx.new(|cx| {
            BufferCodegen::new(
@@ -621,14 +619,14 @@ impl InlineAssistant {
            BlockProperties {
                style: BlockStyle::Sticky,
                placement: BlockPlacement::Above(range.start),
-                height: Some(prompt_editor_height),
+                height: prompt_editor_height,
                render: build_assist_editor_renderer(prompt_editor),
                priority: 0,
            },
            BlockProperties {
                style: BlockStyle::Sticky,
                placement: BlockPlacement::Below(range.end),
-                height: None,
+                height: 0,
                render: Arc::new(|cx| {
                    v_flex()
                        .h_full()
@@ -976,7 +974,7 @@ impl InlineAssistant {
            let active_alternative = assist.codegen.read(cx).active_alternative().clone();
            let message_id = active_alternative.read(cx).message_id.clone();

-            if let Some(model) = LanguageModelRegistry::read_global(cx).inline_assistant_model() {
+            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
                let language_name = assist.editor.upgrade().and_then(|editor| {
                    let multibuffer = editor.read(cx).buffer().read(cx);
                    let snapshot = multibuffer.snapshot(cx);
@@ -996,15 +994,15 @@ impl InlineAssistant {
                        } else {
                            AssistantPhase::Accepted
                        },
-                        model: model.model.telemetry_id(),
-                        model_provider: model.model.provider_id().to_string(),
+                        model: model.telemetry_id(),
+                        model_provider: model.provider_id().to_string(),
                        response_latency: None,
                        error_message: None,
                        language_name: language_name.map(|name| name.to_proto()),
                    },
                    Some(self.telemetry.clone()),
                    cx.http_client(),
-                    model.model.api_key(cx),
+                    model.api_key(cx),
                    cx.background_executor(),
                );
            }
@@ -1365,7 +1363,10 @@ impl InlineAssistant {
                    multi_buffer.update(cx, |multi_buffer, cx| {
                        multi_buffer.push_excerpts(
                            old_buffer.clone(),
-                            Some(ExcerptRange::new(buffer_start..buffer_end)),
+                            Some(ExcerptRange {
+                                context: buffer_start..buffer_end,
+                                primary: None,
+                            }),
                            cx,
                        );
                    });
@@ -1392,7 +1393,7 @@ impl InlineAssistant {
                    deleted_lines_editor.update(cx, |editor, cx| editor.max_point(cx).row().0 + 1);
                new_blocks.push(BlockProperties {
                    placement: BlockPlacement::Above(new_row),
-                    height: Some(height),
+                    height,
                    style: BlockStyle::Flex,
                    render: Arc::new(move |cx| {
                        div()
--- a/crates/assistant2/src/inline_prompt_editor.rs
+++ b/crates/assistant2/src/inline_prompt_editor.rs
@@ -1,4 +1,4 @@
-use crate::assistant_model_selector::{AssistantModelSelector, ModelType};
+use crate::assistant_model_selector::AssistantModelSelector;
 use crate::buffer_codegen::BufferCodegen;
 use crate::context_picker::ContextPicker;
 use crate::context_store::ContextStore;
@@ -582,7 +582,7 @@ impl<T: 'static> PromptEditor<T> {
        let disabled = matches!(codegen.status(cx), CodegenStatus::Idle);

        let model_registry = LanguageModelRegistry::read_global(cx);
-        let default_model = model_registry.default_model().map(|default| default.model);
+        let default_model = model_registry.active_model();
        let alternative_models = model_registry.inline_alternative_models();

        let get_model_name = |index: usize| -> String {
@@ -890,7 +890,6 @@ impl PromptEditor<BufferCodegen> {
                    fs,
                    model_selector_menu_handle,
                    prompt_editor.focus_handle(cx),
-                    ModelType::InlineAssistant,
                    window,
                    cx,
                )
@@ -1043,7 +1042,6 @@ impl PromptEditor<TerminalCodegen> {
                    fs,
                    model_selector_menu_handle.clone(),
                    prompt_editor.focus_handle(cx),
-                    ModelType::InlineAssistant,
                    window,
                    cx,
                )
--- a/crates/assistant2/src/message_editor.rs
+++ b/crates/assistant2/src/message_editor.rs
@@ -1,6 +1,5 @@
 use std::sync::Arc;

-use crate::assistant_model_selector::ModelType;
 use collections::HashSet;
 use editor::actions::MoveUp;
 use editor::{ContextMenuOptions, ContextMenuPlacement, Editor, EditorElement, EditorStyle};
@@ -10,10 +9,8 @@ use gpui::{
    Animation, AnimationExt, App, DismissEvent, Entity, Focusable, Subscription, TextStyle,
    WeakEntity, linear_color_stop, linear_gradient, point,
 };
-use language::Buffer;
-use language_model::{ConfiguredModel, LanguageModelRegistry};
+use language_model::LanguageModelRegistry;
 use language_model_selector::ToggleModelSelector;
-use multi_buffer;
 use project::Project;
 use settings::Settings;
 use std::time::Duration;
@@ -22,7 +19,7 @@ use ui::{
    ButtonLike, Disclosure, KeyBinding, PlatformStyle, PopoverMenu, PopoverMenuHandle, Tooltip,
    prelude::*,
 };
-use util::ResultExt as _;
+use util::ResultExt;
 use vim_mode_setting::VimModeSetting;
 use workspace::Workspace;

@@ -31,10 +28,10 @@ use crate::context_picker::{ConfirmBehavior, ContextPicker, ContextPickerComplet
 use crate::context_store::{ContextStore, refresh_context_store_text};
 use crate::context_strip::{ContextStrip, ContextStripEvent, SuggestContextKind};
 use crate::profile_selector::ProfileSelector;
-use crate::thread::{RequestKind, Thread, TokenUsageRatio};
+use crate::thread::{RequestKind, Thread};
 use crate::thread_store::ThreadStore;
 use crate::{
-    AgentDiff, Chat, ChatMode, NewThread, OpenAgentDiff, RemoveAllContext, ThreadEvent,
+    AssistantDiff, Chat, ChatMode, OpenAssistantDiff, RemoveAllContext, ThreadEvent,
    ToggleContextPicker, ToggleProfileSelector,
 };

@@ -52,7 +49,6 @@ pub struct MessageEditor {
    model_selector: Entity<AssistantModelSelector>,
    profile_selector: Entity<ProfileSelector>,
    edits_expanded: bool,
-    waiting_for_summaries_to_send: bool,
    _subscriptions: Vec<Subscription>,
 }

@@ -140,13 +136,11 @@ impl MessageEditor {
                    fs.clone(),
                    model_selector_menu_handle,
                    editor.focus_handle(cx),
-                    ModelType::Default,
                    window,
                    cx,
                )
            }),
            edits_expanded: false,
-            waiting_for_summaries_to_send: false,
            profile_selector: cx
                .new(|cx| ProfileSelector::new(fs, thread_store, editor.focus_handle(cx), cx)),
            _subscriptions: subscriptions,
@@ -193,7 +187,7 @@ impl MessageEditor {

    fn is_model_selected(&self, cx: &App) -> bool {
        LanguageModelRegistry::read_global(cx)
-            .default_model()
+            .active_model()
            .is_some()
    }

@@ -203,16 +197,20 @@ impl MessageEditor {
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
-        let model_registry = LanguageModelRegistry::read_global(cx);
-        let Some(ConfiguredModel { model, provider }) = model_registry.default_model() else {
-            return;
-        };
-
-        if provider.must_accept_terms(cx) {
+        let provider = LanguageModelRegistry::read_global(cx).active_provider();
+        if provider
+            .as_ref()
+            .map_or(false, |provider| provider.must_accept_terms(cx))
+        {
            cx.notify();
            return;
        }

+        let model_registry = LanguageModelRegistry::read_global(cx);
+        let Some(model) = model_registry.active_model() else {
+            return;
+        };
+
        let user_message = self.editor.update(cx, |editor, cx| {
            let text = editor.text(cx);
            editor.clear(window, cx);
@@ -227,12 +225,10 @@ impl MessageEditor {
        let thread = self.thread.clone();
        let context_store = self.context_store.clone();
        let checkpoint = self.project.read(cx).git_store().read(cx).checkpoint(cx);
-
-        cx.spawn(async move |this, cx| {
+        cx.spawn(async move |_, cx| {
            let checkpoint = checkpoint.await.ok();
            refresh_task.await;
            let (system_prompt_context, load_error) = system_prompt_context_task.await;
-
            thread
                .update(cx, |thread, cx| {
                    thread.set_system_prompt_context(system_prompt_context);
@@ -240,40 +236,17 @@ impl MessageEditor {
                        cx.emit(ThreadEvent::ShowError(load_error));
                    }
                })
-                .log_err();
-
+                .ok();
            thread
                .update(cx, |thread, cx| {
                    let context = context_store.read(cx).context().clone();
+                    thread.action_log().update(cx, |action_log, cx| {
+                        action_log.clear_reviewed_changes(cx);
+                    });
                    thread.insert_user_message(user_message, context, checkpoint, cx);
-                })
-                .log_err();
-
-            if let Some(wait_for_summaries) = context_store
-                .update(cx, |context_store, cx| context_store.wait_for_summaries(cx))
-                .log_err()
-            {
-                this.update(cx, |this, cx| {
-                    this.waiting_for_summaries_to_send = true;
-                    cx.notify();
-                })
-                .log_err();
-
-                wait_for_summaries.await;
-
-                this.update(cx, |this, cx| {
-                    this.waiting_for_summaries_to_send = false;
-                    cx.notify();
-                })
-                .log_err();
-            }
-
-            // Send to model after summaries are done
-            thread
-                .update(cx, |thread, cx| {
                    thread.send_to_model(model, request_kind, cx);
                })
-                .log_err();
+                .ok();
        })
        .detach();
    }
@@ -318,20 +291,7 @@ impl MessageEditor {
    }

    fn handle_review_click(&self, window: &mut Window, cx: &mut Context<Self>) {
-        AgentDiff::deploy(self.thread.clone(), self.workspace.clone(), window, cx).log_err();
-    }
-
-    fn handle_file_click(
-        &self,
-        buffer: Entity<Buffer>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        if let Ok(diff) = AgentDiff::deploy(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));
-        }
+        AssistantDiff::deploy(self.thread.clone(), self.workspace.clone(), window, cx).log_err();
    }
 }

@@ -349,14 +309,9 @@ impl Render for MessageEditor {
        let focus_handle = self.editor.focus_handle(cx);
        let inline_context_picker = self.inline_context_picker.clone();

-        let thread = self.thread.read(cx);
-        let is_generating = thread.is_generating();
-        let total_token_usage = thread.total_token_usage(cx);
+        let is_generating = self.thread.read(cx).is_generating();
        let is_model_selected = self.is_model_selected(cx);
        let is_editor_empty = self.is_editor_empty(cx);
-        let needs_confirmation =
-            thread.has_pending_tool_uses() && thread.tools_needing_confirmation().next().is_some();
-
        let submit_label_color = if is_editor_empty {
            Color::Muted
        } else {
@@ -384,41 +339,6 @@ impl Render for MessageEditor {

        v_flex()
            .size_full()
-            .when(self.waiting_for_summaries_to_send, |parent| {
-                parent.child(
-                    h_flex().py_3().w_full().justify_center().child(
-                        h_flex()
-                            .flex_none()
-                            .px_2()
-                            .py_2()
-                            .bg(editor_bg_color)
-                            .border_1()
-                            .border_color(cx.theme().colors().border_variant)
-                            .rounded_lg()
-                            .shadow_md()
-                            .gap_1()
-                            .child(
-                                Icon::new(IconName::ArrowCircle)
-                                    .size(IconSize::XSmall)
-                                    .color(Color::Muted)
-                                    .with_animation(
-                                        "arrow-circle",
-                                        Animation::new(Duration::from_secs(2)).repeat(),
-                                        |icon, delta| {
-                                            icon.transform(gpui::Transformation::rotate(
-                                                gpui::percentage(delta),
-                                            ))
-                                        },
-                                    ),
-                            )
-                            .child(
-                                Label::new("Summarizing context…")
-                                    .size(LabelSize::XSmall)
-                                    .color(Color::Muted),
-                            ),
-                    ),
-                )
-            })
            .when(is_generating, |parent| {
                let focus_handle = self.editor.focus_handle(cx).clone();
                parent.child(
@@ -448,17 +368,11 @@ impl Render for MessageEditor {
                                        },
                                    ),
                            )
-                            .child({
-
-
-                                Label::new(if needs_confirmation {
-                                    "Waiting for confirmation…"
-                                } else {
-                                    "Generating…"
-                                })
-                                .size(LabelSize::XSmall)
-                                .color(Color::Muted)
-                            })
+                            .child(
+                                Label::new("Generating…")
+                                    .size(LabelSize::XSmall)
+                                    .color(Color::Muted),
+                            )
                            .child(ui::Divider::vertical())
                            .child(
                                Button::new("cancel-generation", "Cancel")
@@ -500,16 +414,11 @@ impl Render for MessageEditor {
                        }])
                        .child(
                            h_flex()
-                                .id("edits-container")
                                .p_1p5()
                                .justify_between()
                                .when(self.edits_expanded, |this| {
                                    this.border_b_1().border_color(border_color)
                                })
-                                .cursor_pointer()
-                                .on_click(cx.listener(|this, _, window, cx| {
-                                    this.handle_review_click(window, cx)
-                                }))
                                .child(
                                    h_flex()
                                        .gap_1()
@@ -554,7 +463,7 @@ impl Render for MessageEditor {
                                        .label_size(LabelSize::Small)
                                        .key_binding(
                                            KeyBinding::for_action_in(
-                                                &OpenAgentDiff,
+                                                &OpenAssistantDiff,
                                                &focus_handle,
                                                window,
                                                cx,
@@ -570,7 +479,7 @@ impl Render for MessageEditor {
                            parent.child(
                                v_flex().bg(cx.theme().colors().editor_background).children(
                                    changed_buffers.into_iter().enumerate().flat_map(
-                                        |(index, (buffer, _diff))| {
+                                        |(index, (buffer, changed))| {
                                            let file = buffer.read(cx).file()?;
                                            let path = file.path();

@@ -623,21 +532,11 @@ impl Render for MessageEditor {
                                                        .justify_between()
                                                        .child(
                                                            h_flex()
-                                                                .id(("file-container", index))
+                                                                .id("file-container")
                                                                .pr_8()
                                                                .gap_1p5()
                                                                .max_w_full()
                                                                .overflow_x_scroll()
-                                                                .cursor_pointer()
-                                                                .on_click({
-                                                                    let buffer = buffer.clone();
-                                                                    cx.listener(move |this, _, window, cx| {
-                                                                        this.handle_file_click(buffer.clone(), window, cx);
-                                                                    })
-                                                                })
-                                                                .tooltip(
-                                                                    Tooltip::text(format!("Review {}", path.display()))
-                                                                )
                                                                .child(file_icon)
                                                                .child(
                                                                    h_flex()
@@ -653,13 +552,25 @@ impl Render for MessageEditor {
                                                                        .color(Color::Deleted),
                                                                ),
                                                        )
+                                                        .when(!changed.needs_review, |parent| {
+                                                            parent.child(
+                                                                Icon::new(IconName::Check)
+                                                                    .color(Color::Success),
+                                                            )
+                                                        })
                                                        .child(
                                                            div()
                                                                .h_full()
                                                                .absolute()
                                                                .w_8()
                                                                .bottom_0()
-                                                                .right_0()
+                                                                .map(|this| {
+                                                                    if !changed.needs_review {
+                                                                        this.right_4()
+                                                                    } else {
+                                                                        this.right_0()
+                                                                    }
+                                                                })
                                                                .bg(linear_gradient(
                                                                    90.,
                                                                    linear_color_stop(
@@ -711,29 +622,28 @@ impl Render for MessageEditor {
                        v_flex()
                            .gap_5()
                            .child({
-                                    let settings = ThemeSettings::get_global(cx);
-                                    let text_style = TextStyle {
-                                        color: cx.theme().colors().text,
-                                        font_family: settings.ui_font.family.clone(),
-                                        font_fallbacks: settings.ui_font.fallbacks.clone(),
-                                        font_features: settings.ui_font.features.clone(),
-                                        font_size: font_size.into(),
-                                        font_weight: settings.ui_font.weight,
-                                        line_height: line_height.into(),
+                                let settings = ThemeSettings::get_global(cx);
+                                let text_style = TextStyle {
+                                    color: cx.theme().colors().text,
+                                    font_family: settings.ui_font.family.clone(),
+                                    font_fallbacks: settings.ui_font.fallbacks.clone(),
+                                    font_features: settings.ui_font.features.clone(),
+                                    font_size: font_size.into(),
+                                    font_weight: settings.ui_font.weight,
+                                    line_height: line_height.into(),
+                                    ..Default::default()
+                                };
+
+                                EditorElement::new(
+                                    &self.editor,
+                                    EditorStyle {
+                                        background: editor_bg_color,
+                                        local_player: cx.theme().players().local(),
+                                        text: text_style,
+                                        syntax: cx.theme().syntax().clone(),
                                        ..Default::default()
-                                    };
-
-                                    EditorElement::new(
-                                        &self.editor,
-                                        EditorStyle {
-                                            background: editor_bg_color,
-                                            local_player: cx.theme().players().local(),
-                                            text: text_style,
-                                            syntax: cx.theme().syntax().clone(),
-                                            ..Default::default()
-                                        },
-                                    ).into_any()
-
+                                    },
+                                )
                            })
                            .child(
                                PopoverMenu::new("inline-context-picker")
@@ -765,8 +675,7 @@ impl Render for MessageEditor {
                                                .disabled(
                                                    is_editor_empty
                                                        || !is_model_selected
-                                                        || is_generating
-                                                        || self.waiting_for_summaries_to_send
+                                                        || is_generating,
                                                )
                                                .child(
                                                    h_flex()
@@ -814,61 +723,7 @@ impl Render for MessageEditor {
                                        ),
                                    ),
                            ),
-                    )
+                    ),
            )
-            .when(total_token_usage.ratio != TokenUsageRatio::Normal, |parent| {
-                parent.child(
-                    h_flex()
-                        .p_2()
-                        .gap_2()
-                        .flex_wrap()
-                        .justify_between()
-                        .bg(cx.theme().status().warning_background.opacity(0.1))
-                        .border_t_1()
-                        .border_color(cx.theme().colors().border)
-                        .child(
-                            h_flex()
-                                .gap_2()
-                                .items_start()
-                                .child(
-                                    h_flex()
-                                        .h(line_height)
-                                        .justify_center()
-                                        .child(
-                                            Icon::new(IconName::Warning)
-                                                .color(Color::Warning)
-                                                .size(IconSize::XSmall),
-                                        ),
-                                )
-                                .child(
-                                    v_flex()
-                                        .mr_auto()
-                                        .child(Label::new("Thread reaching the token limit soon").size(LabelSize::Small))
-                                        .child(
-                                            Label::new(
-                                                "Start a new thread from a summary to continue the conversation.",
-                                            )
-                                            .size(LabelSize::Small)
-                                            .color(Color::Muted),
-                                        ),
-                                ),
-                        )
-                        .child(
-                            Button::new("new-thread", "Start New Thread")
-                                .on_click(cx.listener(|this, _, window, cx| {
-                                    let from_thread_id = Some(this.thread.read(cx).id().clone());
-
-                                    window.dispatch_action(Box::new(NewThread {
-                                        from_thread_id
-                                    }), cx);
-                                }))
-                                .icon(IconName::Plus)
-                                .icon_position(IconPosition::Start)
-                                .icon_size(IconSize::Small)
-                                .style(ButtonStyle::Tinted(ui::TintColor::Accent))
-                                .label_size(LabelSize::Small),
-                        ),
-                )
-            })
    }
 }
--- a/crates/assistant2/src/profile_selector.rs
+++ b/crates/assistant2/src/profile_selector.rs
@@ -1,13 +1,12 @@
 use std::sync::Arc;

-use assistant_settings::{AgentProfile, AgentProfileId, AssistantSettings};
+use assistant_settings::{AgentProfile, AssistantSettings};
 use fs::Fs;
 use gpui::{Action, Entity, FocusHandle, Subscription, WeakEntity, prelude::*};
 use indexmap::IndexMap;
-use language_model::LanguageModelRegistry;
 use settings::{Settings as _, SettingsStore, update_settings_file};
 use ui::{
-    ButtonLike, ContextMenu, ContextMenuEntry, KeyBinding, PopoverMenu, PopoverMenuHandle, Tooltip,
+    ButtonLike, ContextMenu, ContextMenuEntry, KeyBinding, PopoverMenu, PopoverMenuHandle,
    prelude::*,
 };
 use util::ResultExt as _;
@@ -15,7 +14,7 @@ use util::ResultExt as _;
 use crate::{ManageProfiles, ThreadStore, ToggleProfileSelector};

 pub struct ProfileSelector {
-    profiles: IndexMap<AgentProfileId, AgentProfile>,
+    profiles: IndexMap<Arc<str>, AgentProfile>,
    fs: Arc<dyn Fs>,
    thread_store: WeakEntity<ThreadStore>,
    focus_handle: FocusHandle,
@@ -128,12 +127,7 @@ impl Render for ProfileSelector {
            .map(|profile| profile.name.clone())
            .unwrap_or_else(|| "Unknown".into());

-        let model_registry = LanguageModelRegistry::read_global(cx);
-        let supports_tools = model_registry
-            .default_model()
-            .map_or(false, |default| default.model.supports_tools());
-
-        let icon = match profile_id.as_str() {
+        let icon = match profile_id.as_ref() {
            "write" => IconName::Pencil,
            "ask" => IconName::MessageBubbles,
            _ => IconName::UserRoundPen,
@@ -145,7 +139,7 @@ impl Render for ProfileSelector {
            .menu(move |window, cx| {
                Some(this.update(cx, |this, cx| this.build_context_menu(window, cx)))
            })
-            .trigger(if supports_tools {
+            .trigger(
                ButtonLike::new("profile-selector-button").child(
                    h_flex()
                        .gap_1()
@@ -170,19 +164,8 @@ impl Render for ProfileSelector {
                            )
                            .map(|kb| kb.size(rems_from_px(10.)))
                        })),
-                )
-            } else {
-                ButtonLike::new("tools-not-supported-button")
-                    .disabled(true)
-                    .child(
-                        h_flex().gap_1().child(
-                            Label::new("No Tools")
-                                .size(LabelSize::Small)
-                                .color(Color::Muted),
-                        ),
-                    )
-                    .tooltip(Tooltip::text("The current model does not support tools."))
-            })
+                ),
+            )
            .anchor(gpui::Corner::BottomLeft)
            .with_handle(self.menu_handle.clone())
    }
--- a/crates/assistant2/src/terminal_codegen.rs
+++ b/crates/assistant2/src/terminal_codegen.rs
@@ -2,9 +2,7 @@ use crate::inline_prompt_editor::CodegenStatus;
 use client::telemetry::Telemetry;
 use futures::{SinkExt, StreamExt, channel::mpsc};
 use gpui::{App, AppContext as _, Context, Entity, EventEmitter, Task};
-use language_model::{
-    ConfiguredModel, LanguageModelRegistry, LanguageModelRequest, report_assistant_event,
-};
+use language_model::{LanguageModelRegistry, LanguageModelRequest, report_assistant_event};
 use std::{sync::Arc, time::Instant};
 use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
 use terminal::Terminal;
@@ -33,9 +31,7 @@ impl TerminalCodegen {
    }

    pub fn start(&mut self, prompt: LanguageModelRequest, cx: &mut Context<Self>) {
-        let Some(ConfiguredModel { model, .. }) =
-            LanguageModelRegistry::read_global(cx).inline_assistant_model()
-        else {
+        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
            return;
        };

--- a/crates/assistant2/src/terminal_inline_assistant.rs
+++ b/crates/assistant2/src/terminal_inline_assistant.rs
@@ -13,8 +13,8 @@ use fs::Fs;
 use gpui::{App, Entity, Focusable, Global, Subscription, UpdateGlobal, WeakEntity};
 use language::Buffer;
 use language_model::{
-    ConfiguredModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
-    Role, report_assistant_event,
+    LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role,
+    report_assistant_event,
 };
 use prompt_store::PromptBuilder;
 use std::sync::Arc;
@@ -75,8 +75,7 @@ impl TerminalInlineAssistant {
        let assist_id = self.next_assist_id.post_inc();
        let prompt_buffer =
            cx.new(|cx| MultiBuffer::singleton(cx.new(|cx| Buffer::local(String::new(), cx)), cx));
-        let context_store =
-            cx.new(|_cx| ContextStore::new(workspace.clone(), thread_store.clone()));
+        let context_store = cx.new(|_cx| ContextStore::new(workspace.clone()));
        let codegen = cx.new(|_| TerminalCodegen::new(terminal, self.telemetry.clone()));

        let prompt_editor = cx.new(|cx| {
@@ -286,9 +285,7 @@ impl TerminalInlineAssistant {
                })
                .log_err();

-            if let Some(ConfiguredModel { model, .. }) =
-                LanguageModelRegistry::read_global(cx).inline_assistant_model()
-            {
+            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
                let codegen = assist.codegen.read(cx);
                let executor = cx.background_executor().clone();
                report_assistant_event(
--- a/crates/assistant2/src/thread.rs
+++ b/crates/assistant2/src/thread.rs
--- a/crates/assistant2/src/thread_history.rs
+++ b/crates/assistant2/src/thread_history.rs
@@ -0,0 +1,411 @@
+use assistant_context_editor::SavedContextMetadata;
+use gpui::{
+    App, Entity, FocusHandle, Focusable, ScrollStrategy, UniformListScrollHandle, WeakEntity,
+    uniform_list,
+};
+use time::{OffsetDateTime, UtcOffset};
+use ui::{IconButtonShape, ListItem, ListItemSpacing, Tooltip, prelude::*};
+
+use crate::history_store::{HistoryEntry, HistoryStore};
+use crate::thread_store::SerializedThreadMetadata;
+use crate::{AssistantPanel, RemoveSelectedThread};
+
+pub struct ThreadHistory {
+    focus_handle: FocusHandle,
+    assistant_panel: WeakEntity<AssistantPanel>,
+    history_store: Entity<HistoryStore>,
+    scroll_handle: UniformListScrollHandle,
+    selected_index: usize,
+}
+
+impl ThreadHistory {
+    pub(crate) fn new(
+        assistant_panel: WeakEntity<AssistantPanel>,
+        history_store: Entity<HistoryStore>,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        Self {
+            focus_handle: cx.focus_handle(),
+            assistant_panel,
+            history_store,
+            scroll_handle: UniformListScrollHandle::default(),
+            selected_index: 0,
+        }
+    }
+
+    pub fn select_previous(
+        &mut self,
+        _: &menu::SelectPrevious,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let count = self
+            .history_store
+            .update(cx, |this, cx| this.entry_count(cx));
+        if count > 0 {
+            if self.selected_index == 0 {
+                self.set_selected_index(count - 1, window, cx);
+            } else {
+                self.set_selected_index(self.selected_index - 1, window, cx);
+            }
+        }
+    }
+
+    pub fn select_next(
+        &mut self,
+        _: &menu::SelectNext,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let count = self
+            .history_store
+            .update(cx, |this, cx| this.entry_count(cx));
+        if count > 0 {
+            if self.selected_index == count - 1 {
+                self.set_selected_index(0, window, cx);
+            } else {
+                self.set_selected_index(self.selected_index + 1, window, cx);
+            }
+        }
+    }
+
+    fn select_first(&mut self, _: &menu::SelectFirst, window: &mut Window, cx: &mut Context<Self>) {
+        let count = self
+            .history_store
+            .update(cx, |this, cx| this.entry_count(cx));
+        if count > 0 {
+            self.set_selected_index(0, window, cx);
+        }
+    }
+
+    fn select_last(&mut self, _: &menu::SelectLast, window: &mut Window, cx: &mut Context<Self>) {
+        let count = self
+            .history_store
+            .update(cx, |this, cx| this.entry_count(cx));
+        if count > 0 {
+            self.set_selected_index(count - 1, window, cx);
+        }
+    }
+
+    fn set_selected_index(&mut self, index: usize, _window: &mut Window, cx: &mut Context<Self>) {
+        self.selected_index = index;
+        self.scroll_handle
+            .scroll_to_item(index, ScrollStrategy::Top);
+        cx.notify();
+    }
+
+    fn confirm(&mut self, _: &menu::Confirm, window: &mut Window, cx: &mut Context<Self>) {
+        let entries = self.history_store.update(cx, |this, cx| this.entries(cx));
+
+        if let Some(entry) = entries.get(self.selected_index) {
+            match entry {
+                HistoryEntry::Thread(thread) => {
+                    self.assistant_panel
+                        .update(cx, move |this, cx| this.open_thread(&thread.id, window, cx))
+                        .ok();
+                }
+                HistoryEntry::Context(context) => {
+                    self.assistant_panel
+                        .update(cx, move |this, cx| {
+                            this.open_saved_prompt_editor(context.path.clone(), window, cx)
+                        })
+                        .ok();
+                }
+            }
+
+            cx.notify();
+        }
+    }
+
+    fn remove_selected_thread(
+        &mut self,
+        _: &RemoveSelectedThread,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let entries = self.history_store.update(cx, |this, cx| this.entries(cx));
+
+        if let Some(entry) = entries.get(self.selected_index) {
+            match entry {
+                HistoryEntry::Thread(thread) => {
+                    self.assistant_panel
+                        .update(cx, |this, cx| {
+                            this.delete_thread(&thread.id, cx);
+                        })
+                        .ok();
+                }
+                HistoryEntry::Context(context) => {
+                    self.assistant_panel
+                        .update(cx, |this, cx| {
+                            this.delete_context(context.path.clone(), cx);
+                        })
+                        .ok();
+                }
+            }
+
+            cx.notify();
+        }
+    }
+}
+
+impl Focusable for ThreadHistory {
+    fn focus_handle(&self, _cx: &App) -> FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Render for ThreadHistory {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let history_entries = self.history_store.update(cx, |this, cx| this.entries(cx));
+        let selected_index = self.selected_index;
+
+        v_flex()
+            .id("thread-history-container")
+            .key_context("ThreadHistory")
+            .track_focus(&self.focus_handle)
+            .overflow_y_scroll()
+            .size_full()
+            .p_1()
+            .on_action(cx.listener(Self::select_previous))
+            .on_action(cx.listener(Self::select_next))
+            .on_action(cx.listener(Self::select_first))
+            .on_action(cx.listener(Self::select_last))
+            .on_action(cx.listener(Self::confirm))
+            .on_action(cx.listener(Self::remove_selected_thread))
+            .map(|history| {
+                if history_entries.is_empty() {
+                    history
+                        .justify_center()
+                        .child(
+                            h_flex().w_full().justify_center().child(
+                                Label::new("You don't have any past threads yet.")
+                                    .size(LabelSize::Small),
+                            ),
+                        )
+                } else {
+                    history.child(
+                        uniform_list(
+                            cx.entity().clone(),
+                            "thread-history",
+                            history_entries.len(),
+                            move |history, range, _window, _cx| {
+                                history_entries[range]
+                                    .iter()
+                                    .enumerate()
+                                    .map(|(index, entry)| {
+                                        h_flex().w_full().pb_1().child(match entry {
+                                            HistoryEntry::Thread(thread) => PastThread::new(
+                                                thread.clone(),
+                                                history.assistant_panel.clone(),
+                                                selected_index == index,
+                                            )
+                                            .into_any_element(),
+                                            HistoryEntry::Context(context) => PastContext::new(
+                                                context.clone(),
+                                                history.assistant_panel.clone(),
+                                                selected_index == index,
+                                            )
+                                            .into_any_element(),
+                                        })
+                                    })
+                                    .collect()
+                            },
+                        )
+                        .track_scroll(self.scroll_handle.clone())
+                        .flex_grow(),
+                    )
+                }
+            })
+    }
+}
+
+#[derive(IntoElement)]
+pub struct PastThread {
+    thread: SerializedThreadMetadata,
+    assistant_panel: WeakEntity<AssistantPanel>,
+    selected: bool,
+}
+
+impl PastThread {
+    pub fn new(
+        thread: SerializedThreadMetadata,
+        assistant_panel: WeakEntity<AssistantPanel>,
+        selected: bool,
+    ) -> Self {
+        Self {
+            thread,
+            assistant_panel,
+            selected,
+        }
+    }
+}
+
+impl RenderOnce for PastThread {
+    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
+        let summary = self.thread.summary;
+
+        let thread_timestamp = time_format::format_localized_timestamp(
+            OffsetDateTime::from_unix_timestamp(self.thread.updated_at.timestamp()).unwrap(),
+            OffsetDateTime::now_utc(),
+            self.assistant_panel
+                .update(cx, |this, _cx| this.local_timezone())
+                .unwrap_or(UtcOffset::UTC),
+            time_format::TimestampFormat::EnhancedAbsolute,
+        );
+
+        ListItem::new(SharedString::from(self.thread.id.to_string()))
+            .rounded()
+            .toggle_state(self.selected)
+            .spacing(ListItemSpacing::Sparse)
+            .start_slot(
+                div()
+                    .max_w_4_5()
+                    .child(Label::new(summary).size(LabelSize::Small).truncate()),
+            )
+            .end_slot(
+                h_flex()
+                    .gap_1p5()
+                    .child(
+                        Label::new("Thread")
+                            .color(Color::Muted)
+                            .size(LabelSize::XSmall),
+                    )
+                    .child(
+                        div()
+                            .size(px(3.))
+                            .rounded_full()
+                            .bg(cx.theme().colors().text_disabled),
+                    )
+                    .child(
+                        Label::new(thread_timestamp)
+                            .color(Color::Muted)
+                            .size(LabelSize::XSmall),
+                    )
+                    .child(
+                        IconButton::new("delete", IconName::TrashAlt)
+                            .shape(IconButtonShape::Square)
+                            .icon_size(IconSize::XSmall)
+                            .tooltip(Tooltip::text("Delete Thread"))
+                            .on_click({
+                                let assistant_panel = self.assistant_panel.clone();
+                                let id = self.thread.id.clone();
+                                move |_event, _window, cx| {
+                                    assistant_panel
+                                        .update(cx, |this, cx| {
+                                            this.delete_thread(&id, cx);
+                                        })
+                                        .ok();
+                                }
+                            }),
+                    ),
+            )
+            .on_click({
+                let assistant_panel = self.assistant_panel.clone();
+                let id = self.thread.id.clone();
+                move |_event, window, cx| {
+                    assistant_panel
+                        .update(cx, |this, cx| {
+                            this.open_thread(&id, window, cx).detach_and_log_err(cx);
+                        })
+                        .ok();
+                }
+            })
+    }
+}
+
+#[derive(IntoElement)]
+pub struct PastContext {
+    context: SavedContextMetadata,
+    assistant_panel: WeakEntity<AssistantPanel>,
+    selected: bool,
+}
+
+impl PastContext {
+    pub fn new(
+        context: SavedContextMetadata,
+        assistant_panel: WeakEntity<AssistantPanel>,
+        selected: bool,
+    ) -> Self {
+        Self {
+            context,
+            assistant_panel,
+            selected,
+        }
+    }
+}
+
+impl RenderOnce for PastContext {
+    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
+        let summary = self.context.title;
+
+        let context_timestamp = time_format::format_localized_timestamp(
+            OffsetDateTime::from_unix_timestamp(self.context.mtime.timestamp()).unwrap(),
+            OffsetDateTime::now_utc(),
+            self.assistant_panel
+                .update(cx, |this, _cx| this.local_timezone())
+                .unwrap_or(UtcOffset::UTC),
+            time_format::TimestampFormat::EnhancedAbsolute,
+        );
+
+        ListItem::new(SharedString::from(
+            self.context.path.to_string_lossy().to_string(),
+        ))
+        .rounded()
+        .toggle_state(self.selected)
+        .spacing(ListItemSpacing::Sparse)
+        .start_slot(
+            div()
+                .max_w_4_5()
+                .child(Label::new(summary).size(LabelSize::Small).truncate()),
+        )
+        .end_slot(
+            h_flex()
+                .gap_1p5()
+                .child(
+                    Label::new("Prompt Editor")
+                        .color(Color::Muted)
+                        .size(LabelSize::XSmall),
+                )
+                .child(
+                    div()
+                        .size(px(3.))
+                        .rounded_full()
+                        .bg(cx.theme().colors().text_disabled),
+                )
+                .child(
+                    Label::new(context_timestamp)
+                        .color(Color::Muted)
+                        .size(LabelSize::XSmall),
+                )
+                .child(
+                    IconButton::new("delete", IconName::TrashAlt)
+                        .shape(IconButtonShape::Square)
+                        .icon_size(IconSize::XSmall)
+                        .tooltip(Tooltip::text("Delete Prompt Editor"))
+                        .on_click({
+                            let assistant_panel = self.assistant_panel.clone();
+                            let path = self.context.path.clone();
+                            move |_event, _window, cx| {
+                                assistant_panel
+                                    .update(cx, |this, cx| {
+                                        this.delete_context(path.clone(), cx);
+                                    })
+                                    .ok();
+                            }
+                        }),
+                ),
+        )
+        .on_click({
+            let assistant_panel = self.assistant_panel.clone();
+            let path = self.context.path.clone();
+            move |_event, window, cx| {
+                assistant_panel
+                    .update(cx, |this, cx| {
+                        this.open_saved_prompt_editor(path.clone(), window, cx)
+                            .detach_and_log_err(cx);
+                    })
+                    .ok();
+            }
+        })
+    }
+}
--- a/crates/assistant2/src/thread_store.rs
+++ b/crates/assistant2/src/thread_store.rs
@@ -3,7 +3,7 @@ use std::path::PathBuf;
 use std::sync::Arc;

 use anyhow::{Result, anyhow};
-use assistant_settings::{AgentProfile, AgentProfileId, AssistantSettings};
+use assistant_settings::{AgentProfile, AssistantSettings};
 use assistant_tool::{ToolId, ToolSource, ToolWorkingSet};
 use chrono::{DateTime, Utc};
 use collections::HashMap;
@@ -12,8 +12,7 @@ use context_server::{ContextServerFactoryRegistry, ContextServerTool};
 use futures::FutureExt as _;
 use futures::future::{self, BoxFuture, Shared};
 use gpui::{
-    App, BackgroundExecutor, Context, Entity, Global, ReadGlobal, SharedString, Subscription, Task,
-    prelude::*,
+    App, BackgroundExecutor, Context, Entity, Global, ReadGlobal, SharedString, Task, prelude::*,
 };
 use heed::Database;
 use heed::types::SerdeBincode;
@@ -21,12 +20,10 @@ use language_model::{LanguageModelToolUseId, Role, TokenUsage};
 use project::Project;
 use prompt_store::PromptBuilder;
 use serde::{Deserialize, Serialize};
-use settings::{Settings as _, SettingsStore};
+use settings::Settings as _;
 use util::ResultExt as _;

-use crate::thread::{
-    DetailedSummaryState, MessageId, ProjectSnapshot, Thread, ThreadEvent, ThreadId,
-};
+use crate::thread::{MessageId, ProjectSnapshot, Thread, ThreadEvent, ThreadId};

 pub fn init(cx: &mut App) {
    ThreadsDatabase::init(cx);
@@ -39,7 +36,6 @@ pub struct ThreadStore {
    context_server_manager: Entity<ContextServerManager>,
    context_server_tool_ids: HashMap<Arc<str>, Vec<ToolId>>,
    threads: Vec<SerializedThreadMetadata>,
-    _subscriptions: Vec<Subscription>,
 }

 impl ThreadStore {
@@ -54,10 +50,6 @@ impl ThreadStore {
            let context_server_manager = cx.new(|cx| {
                ContextServerManager::new(context_server_factory_registry, project.clone(), cx)
            });
-            let settings_subscription =
-                cx.observe_global::<SettingsStore>(move |this: &mut Self, cx| {
-                    this.load_default_profile(cx);
-                });

            let this = Self {
                project,
@@ -66,7 +58,6 @@ impl ThreadStore {
                context_server_manager,
                context_server_tool_ids: HashMap::default(),
                threads: Vec::new(),
-                _subscriptions: vec![settings_subscription],
            };
            this.load_default_profile(cx);
            this.register_context_server_handlers(cx);
@@ -174,9 +165,8 @@ impl ThreadStore {
            let database = database_future.await.map_err(|err| anyhow!(err))?;
            database.delete_thread(id.clone()).await?;

-            this.update(cx, |this, cx| {
-                this.threads.retain(|thread| thread.id != id);
-                cx.notify();
+            this.update(cx, |this, _cx| {
+                this.threads.retain(|thread| thread.id != id)
            })
        })
    }
@@ -203,15 +193,15 @@ impl ThreadStore {
        self.load_profile_by_id(&assistant_settings.default_profile, cx);
    }

-    pub fn load_profile_by_id(&self, profile_id: &AgentProfileId, cx: &Context<Self>) {
+    pub fn load_profile_by_id(&self, profile_id: &Arc<str>, cx: &Context<Self>) {
        let assistant_settings = AssistantSettings::get_global(cx);

        if let Some(profile) = assistant_settings.profiles.get(profile_id) {
-            self.load_profile(profile, cx);
+            self.load_profile(profile);
        }
    }

-    pub fn load_profile(&self, profile: &AgentProfile, cx: &Context<Self>) {
+    pub fn load_profile(&self, profile: &AgentProfile) {
        self.tools.disable_all_tools();
        self.tools.enable(
            ToolSource::Native,
@@ -222,28 +212,17 @@ impl ThreadStore {
                .collect::<Vec<_>>(),
        );

-        if profile.enable_all_context_servers {
-            for context_server in self.context_server_manager.read(cx).all_servers() {
-                self.tools.enable_source(
-                    ToolSource::ContextServer {
-                        id: context_server.id().into(),
-                    },
-                    cx,
-                );
-            }
-        } else {
-            for (context_server_id, preset) in &profile.context_servers {
-                self.tools.enable(
-                    ToolSource::ContextServer {
-                        id: context_server_id.clone().into(),
-                    },
-                    &preset
-                        .tools
-                        .iter()
-                        .filter_map(|(tool, enabled)| enabled.then(|| tool.clone()))
-                        .collect::<Vec<_>>(),
-                )
-            }
+        for (context_server_id, preset) in &profile.context_servers {
+            self.tools.enable(
+                ToolSource::ContextServer {
+                    id: context_server_id.clone().into(),
+                },
+                &preset
+                    .tools
+                    .iter()
+                    .filter_map(|(tool, enabled)| enabled.then(|| tool.clone()))
+                    .collect::<Vec<_>>(),
+            )
        }
    }

@@ -294,9 +273,8 @@ impl ThreadStore {
                                        })
                                        .collect::<Vec<_>>();

-                                    this.update(cx, |this, cx| {
+                                    this.update(cx, |this, _cx| {
                                        this.context_server_tool_ids.insert(server_id, tool_ids);
-                                        this.load_default_profile(cx);
                                    })
                                    .log_err();
                                }
@@ -309,7 +287,6 @@ impl ThreadStore {
            context_server::manager::Event::ServerStopped { server_id } => {
                if let Some(tool_ids) = self.context_server_tool_ids.remove(server_id) {
                    tool_working_set.remove(&tool_ids);
-                    self.load_default_profile(cx);
                }
            }
        }
@@ -323,7 +300,7 @@ pub struct SerializedThreadMetadata {
    pub updated_at: DateTime<Utc>,
 }

-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize)]
 pub struct SerializedThread {
    pub version: String,
    pub summary: SharedString,
@@ -333,8 +310,6 @@ pub struct SerializedThread {
    pub initial_project_snapshot: Option<Arc<ProjectSnapshot>>,
    #[serde(default)]
    pub cumulative_token_usage: TokenUsage,
-    #[serde(default)]
-    pub detailed_summary_state: DetailedSummaryState,
 }

 impl SerializedThread {
@@ -375,8 +350,6 @@ pub struct SerializedMessage {
    pub tool_uses: Vec<SerializedToolUse>,
    #[serde(default)]
    pub tool_results: Vec<SerializedToolResult>,
-    #[serde(default)]
-    pub context: String,
 }

 #[derive(Debug, Serialize, Deserialize)]
@@ -420,7 +393,6 @@ impl LegacySerializedThread {
            messages: self.messages.into_iter().map(|msg| msg.upgrade()).collect(),
            initial_project_snapshot: self.initial_project_snapshot,
            cumulative_token_usage: TokenUsage::default(),
-            detailed_summary_state: DetailedSummaryState::default(),
        }
    }
 }
@@ -444,7 +416,6 @@ impl LegacySerializedMessage {
            segments: vec![SerializedMessageSegment::Text { text: self.text }],
            tool_uses: self.tool_uses,
            tool_results: self.tool_results,
-            context: String::new(),
        }
    }
 }
--- a/crates/assistant2/src/tool_use.rs
+++ b/crates/assistant2/src/tool_use.rs
@@ -35,18 +35,6 @@ pub enum ToolUseStatus {
    Error(SharedString),
 }

-impl ToolUseStatus {
-    pub fn text(&self) -> SharedString {
-        match self {
-            ToolUseStatus::NeedsConfirmation => "".into(),
-            ToolUseStatus::Pending => "".into(),
-            ToolUseStatus::Running => "".into(),
-            ToolUseStatus::Finished(out) => out.clone(),
-            ToolUseStatus::Error(out) => out.clone(),
-        }
-    }
-}
-
 pub struct ToolUseState {
    tools: Arc<ToolWorkingSet>,
    tool_uses_by_assistant_message: HashMap<MessageId, Vec<LanguageModelToolUse>>,
@@ -55,8 +43,6 @@ pub struct ToolUseState {
    pending_tool_uses_by_id: HashMap<LanguageModelToolUseId, PendingToolUse>,
 }

-pub const USING_TOOL_MARKER: &str = "<using_tool>";
-
 impl ToolUseState {
    pub fn new(tools: Arc<ToolWorkingSet>) -> Self {
        Self {
@@ -371,28 +357,8 @@ impl ToolUseState {
        request_message: &mut LanguageModelRequestMessage,
    ) {
        if let Some(tool_uses) = self.tool_uses_by_assistant_message.get(&message_id) {
-            let mut found_tool_use = false;
-
            for tool_use in tool_uses {
                if self.tool_results.contains_key(&tool_use.id) {
-                    if !found_tool_use {
-                        // The API fails if a message contains a tool use without any (non-whitespace) text around it
-                        match request_message.content.last_mut() {
-                            Some(MessageContent::Text(txt)) => {
-                                if txt.is_empty() {
-                                    txt.push_str(USING_TOOL_MARKER);
-                                }
-                            }
-                            None | Some(_) => {
-                                request_message
-                                    .content
-                                    .push(MessageContent::Text(USING_TOOL_MARKER.into()));
-                            }
-                        };
-                    }
-
-                    found_tool_use = true;
-
                    // Do not send tool uses until they are completed
                    request_message
                        .content
--- a/crates/assistant2/src/ui.rs
+++ b/crates/assistant2/src/ui.rs
--- a/crates/assistant2/src/ui/agent_notification.rs
+++ b/crates/assistant2/src/ui/agent_notification.rs
@@ -118,13 +118,12 @@ impl Render for AgentNotification {
                    )
                    .child(
                        v_flex()
-                            .flex_1()
-                            .max_w(px(300.))
                            .child(
                                div()
                                    .relative()
                                    .text_size(px(14.))
                                    .text_color(cx.theme().colors().text)
+                                    .max_w(px(300.))
                                    .truncate()
                                    .child(self.title.clone())
                                    .child(gradient_overflow()),
@@ -134,6 +133,7 @@ impl Render for AgentNotification {
                                    .relative()
                                    .text_size(px(12.))
                                    .text_color(cx.theme().colors().text_muted)
+                                    .max_w(px(340.))
                                    .truncate()
                                    .child(self.caption.clone())
                                    .child(gradient_overflow()),
--- a/crates/assistant2/src/ui/context_pill.rs
+++ b/crates/assistant2/src/ui/context_pill.rs
@@ -1,8 +1,7 @@
-use std::{rc::Rc, time::Duration};
+use std::rc::Rc;

 use file_icons::FileIcons;
 use gpui::ClickEvent;
-use gpui::{Animation, AnimationExt as _, pulsating_between};
 use ui::{IconButtonShape, Tooltip, prelude::*};

 use crate::context::{AssistantContext, ContextId, ContextKind};
@@ -171,22 +170,6 @@ impl RenderOnce for ContextPill {
                    element
                        .cursor_pointer()
                        .on_click(move |event, window, cx| on_click(event, window, cx))
-                })
-                .map(|element| {
-                    if context.summarizing {
-                        element
-                            .tooltip(ui::Tooltip::text("Summarizing..."))
-                            .with_animation(
-                                "pulsating-ctx-pill",
-                                Animation::new(Duration::from_secs(2))
-                                    .repeat()
-                                    .with_easing(pulsating_between(0.4, 0.8)),
-                                |label, delta| label.opacity(delta),
-                            )
-                            .into_any_element()
-                    } else {
-                        element.into_any()
-                    }
                }),
            ContextPill::Suggested {
                name,
@@ -237,8 +220,7 @@ impl RenderOnce for ContextPill {
                .when_some(on_click.as_ref(), |element, on_click| {
                    let on_click = on_click.clone();
                    element.on_click(move |event, window, cx| on_click(event, window, cx))
-                })
-                .into_any(),
+                }),
        }
    }
 }
@@ -250,7 +232,6 @@ pub struct AddedContext {
    pub parent: Option<SharedString>,
    pub tooltip: Option<SharedString>,
    pub icon_path: Option<SharedString>,
-    pub summarizing: bool,
 }

 impl AddedContext {
@@ -275,7 +256,6 @@ impl AddedContext {
                    parent,
                    tooltip: Some(full_path_string),
                    icon_path: FileIcons::get_icon(&full_path, cx),
-                    summarizing: false,
                }
            }

@@ -300,7 +280,6 @@ impl AddedContext {
                    parent,
                    tooltip: Some(full_path_string),
                    icon_path: None,
-                    summarizing: false,
                }
            }

@@ -311,7 +290,6 @@ impl AddedContext {
                parent: None,
                tooltip: None,
                icon_path: None,
-                summarizing: false,
            },

            AssistantContext::FetchedUrl(fetched_url_context) => AddedContext {
@@ -321,7 +299,6 @@ impl AddedContext {
                parent: None,
                tooltip: None,
                icon_path: None,
-                summarizing: false,
            },

            AssistantContext::Thread(thread_context) => AddedContext {
@@ -331,10 +308,6 @@ impl AddedContext {
                parent: None,
                tooltip: None,
                icon_path: None,
-                summarizing: thread_context
-                    .thread
-                    .read(cx)
-                    .is_generating_detailed_summary(),
            },
        }
    }
--- a/crates/assistant_context_editor/Cargo.toml
+++ b/crates/assistant_context_editor/Cargo.toml
@@ -22,7 +22,6 @@ clock.workspace = true
 collections.workspace = true
 context_server.workspace = true
 editor.workspace = true
-feature_flags.workspace = true
 fs.workspace = true
 futures.workspace = true
 fuzzy.workspace = true
@@ -54,9 +53,7 @@ theme.workspace = true
 ui.workspace = true
 util.workspace = true
 uuid.workspace = true
-workspace-hack.workspace = true
 workspace.workspace = true
-zed_actions.workspace = true

 [dev-dependencies]
 language_model = { workspace = true, features = ["test-support"] }
--- a/crates/assistant_context_editor/src/context.rs
+++ b/crates/assistant_context_editor/src/context.rs
@@ -1272,7 +1272,7 @@ impl AssistantContext {
        // Assume it will be a Chat request, even though that takes fewer tokens (and risks going over the limit),
        // because otherwise you see in the UI that your empty message has a bunch of tokens already used.
        let request = self.to_completion_request(RequestType::Chat, cx);
-        let Some(model) = LanguageModelRegistry::read_global(cx).default_model() else {
+        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
            return;
        };
        let debounce = self.token_count.is_some();
@@ -1284,12 +1284,10 @@ impl AssistantContext {
                        .await;
                }

-                let token_count = cx
-                    .update(|cx| model.model.count_tokens(request, cx))?
-                    .await?;
+                let token_count = cx.update(|cx| model.count_tokens(request, cx))?.await?;
                this.update(cx, |this, cx| {
                    this.token_count = Some(token_count);
-                    this.start_cache_warming(&model.model, cx);
+                    this.start_cache_warming(&model, cx);
                    cx.notify()
                })
            }
@@ -2306,16 +2304,14 @@ impl AssistantContext {
        cx: &mut Context<Self>,
    ) -> Option<MessageAnchor> {
        let model_registry = LanguageModelRegistry::read_global(cx);
-        let model = model_registry.default_model()?;
+        let provider = model_registry.active_provider()?;
+        let model = model_registry.active_model()?;
        let last_message_id = self.get_last_valid_message_id(cx)?;

-        if !model.provider.is_authenticated(cx) {
+        if !provider.is_authenticated(cx) {
            log::info!("completion provider has no credentials");
            return None;
        }
-
-        let model = model.model;
-
        // Compute which messages to cache, including the last one.
        self.mark_cache_anchors(&model.cache_configuration(), false, cx);

@@ -2944,12 +2940,15 @@ impl AssistantContext {
    }

    pub fn summarize(&mut self, replace_old: bool, cx: &mut Context<Self>) {
-        let Some(model) = LanguageModelRegistry::read_global(cx).default_model() else {
+        let Some(provider) = LanguageModelRegistry::read_global(cx).active_provider() else {
+            return;
+        };
+        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
            return;
        };

        if replace_old || (self.message_anchors.len() >= 2 && self.summary.is_none()) {
-            if !model.provider.is_authenticated(cx) {
+            if !provider.is_authenticated(cx) {
                return;
            }

@@ -2965,7 +2964,7 @@ impl AssistantContext {

            self.pending_summary = cx.spawn(async move |this, cx| {
                async move {
-                    let stream = model.model.stream_completion_text(request, &cx);
+                    let stream = model.stream_completion_text(request, &cx);
                    let mut messages = stream.await?;

                    let mut replaced = !replace_old;
--- a/crates/assistant_context_editor/src/context_editor.rs
+++ b/crates/assistant_context_editor/src/context_editor.rs
@@ -18,7 +18,6 @@ use editor::{
    scroll::Autoscroll,
 };
 use editor::{FoldPlaceholder, display_map::CreaseId};
-use feature_flags::{Assistant2FeatureFlag, FeatureFlagAppExt as _};
 use fs::Fs;
 use futures::FutureExt;
 use gpui::{
@@ -57,7 +56,8 @@ use ui::{
 use util::{ResultExt, maybe};
 use workspace::searchable::{Direction, SearchableItemHandle};
 use workspace::{
-    Save, Toast, ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView, Workspace,
+    Save, ShowConfiguration, Toast, ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView,
+    Workspace,
    item::{self, FollowableItem, Item, ItemHandle},
    notifications::NotificationId,
    pane::{self, SaveIntent},
@@ -384,9 +384,7 @@ impl ContextEditor {
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
-        let provider = LanguageModelRegistry::read_global(cx)
-            .default_model()
-            .map(|default| default.provider);
+        let provider = LanguageModelRegistry::read_global(cx).active_provider();
        if provider
            .as_ref()
            .map_or(false, |provider| provider.must_accept_terms(cx))
@@ -1562,7 +1560,7 @@ impl ContextEditor {
                })
            };
            let create_block_properties = |message: &Message| BlockProperties {
-                height: Some(2),
+                height: 2,
                style: BlockStyle::Sticky,
                placement: BlockPlacement::Above(
                    buffer
@@ -2111,7 +2109,7 @@ impl ContextEditor {
                    let image = render_image.clone();
                    anchor.is_valid(&buffer).then(|| BlockProperties {
                        placement: BlockPlacement::Above(anchor),
-                        height: Some(MAX_HEIGHT_IN_LINES),
+                        height: MAX_HEIGHT_IN_LINES,
                        style: BlockStyle::Sticky,
                        render: Arc::new(move |cx| {
                            let image_size = size_for_image(
@@ -2359,19 +2357,7 @@ impl ContextEditor {
                            .on_click({
                                let focus_handle = self.focus_handle(cx).clone();
                                move |_event, window, cx| {
-                                    if cx.has_flag::<Assistant2FeatureFlag>() {
-                                        focus_handle.dispatch_action(
-                                            &zed_actions::agent::OpenConfiguration,
-                                            window,
-                                            cx,
-                                        );
-                                    } else {
-                                        focus_handle.dispatch_action(
-                                            &zed_actions::assistant::ShowConfiguration,
-                                            window,
-                                            cx,
-                                        );
-                                    };
+                                    focus_handle.dispatch_action(&ShowConfiguration, window, cx);
                                }
                            }),
                    )
@@ -2409,13 +2395,13 @@ impl ContextEditor {
            None => (ButtonStyle::Filled, None),
        };

-        let model = LanguageModelRegistry::read_global(cx).default_model();
+        let provider = LanguageModelRegistry::read_global(cx).active_provider();

        let has_configuration_error = configuration_error(cx).is_some();
        let needs_to_accept_terms = self.show_accept_terms
-            && model
+            && provider
                .as_ref()
-                .map_or(false, |model| model.provider.must_accept_terms(cx));
+                .map_or(false, |provider| provider.must_accept_terms(cx));
        let disabled = has_configuration_error || needs_to_accept_terms;

        ButtonLike::new("send_button")
@@ -2468,9 +2454,7 @@ impl ContextEditor {
            None => (ButtonStyle::Filled, None),
        };

-        let provider = LanguageModelRegistry::read_global(cx)
-            .default_model()
-            .map(|default| default.provider);
+        let provider = LanguageModelRegistry::read_global(cx).active_provider();

        let has_configuration_error = configuration_error(cx).is_some();
        let needs_to_accept_terms = self.show_accept_terms
@@ -2516,9 +2500,7 @@ impl ContextEditor {
    }

    fn render_language_model_selector(&self, cx: &mut Context<Self>) -> impl IntoElement {
-        let active_model = LanguageModelRegistry::read_global(cx)
-            .default_model()
-            .map(|default| default.model);
+        let active_model = LanguageModelRegistry::read_global(cx).active_model();
        let focus_handle = self.editor().focus_handle(cx).clone();
        let model_name = match active_model {
            Some(model) => model.name().0,
@@ -3038,9 +3020,7 @@ impl EventEmitter<SearchEvent> for ContextEditor {}

 impl Render for ContextEditor {
    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let provider = LanguageModelRegistry::read_global(cx)
-            .default_model()
-            .map(|default| default.provider);
+        let provider = LanguageModelRegistry::read_global(cx).active_provider();
        let accept_terms = if self.show_accept_terms {
            provider.as_ref().and_then(|provider| {
                provider.render_accept_terms(LanguageModelProviderTosView::PromptEditorPopup, cx)
@@ -3636,9 +3616,7 @@ enum TokenState {
 fn token_state(context: &Entity<AssistantContext>, cx: &App) -> Option<TokenState> {
    const WARNING_TOKEN_THRESHOLD: f32 = 0.8;

-    let model = LanguageModelRegistry::read_global(cx)
-        .default_model()?
-        .model;
+    let model = LanguageModelRegistry::read_global(cx).active_model()?;
    let token_count = context.read(cx).token_count()?;
    let max_token_count = model.max_token_count();

@@ -3691,16 +3669,16 @@ pub enum ConfigurationError {
 }

 fn configuration_error(cx: &App) -> Option<ConfigurationError> {
-    let model = LanguageModelRegistry::read_global(cx).default_model();
-    let is_authenticated = model
+    let provider = LanguageModelRegistry::read_global(cx).active_provider();
+    let is_authenticated = provider
        .as_ref()
-        .map_or(false, |model| model.provider.is_authenticated(cx));
+        .map_or(false, |provider| provider.is_authenticated(cx));

-    if model.is_some() && is_authenticated {
+    if provider.is_some() && is_authenticated {
        return None;
    }

-    if model.is_none() {
+    if provider.is_none() {
        return Some(ConfigurationError::NoProvider);
    }

@@ -3725,18 +3703,6 @@ pub fn humanize_token_count(count: usize) -> String {
                format!("{}.{}k", thousands, hundreds)
            }
        }
-        1_000_000..=9_999_999 => {
-            let millions = count / 1_000_000;
-            let hundred_thousands = (count % 1_000_000 + 50_000) / 100_000;
-            if hundred_thousands == 0 {
-                format!("{}M", millions)
-            } else if hundred_thousands == 10 {
-                format!("{}M", millions + 1)
-            } else {
-                format!("{}.{}M", millions, hundred_thousands)
-            }
-        }
-        10_000_000.. => format!("{}M", (count + 500_000) / 1_000_000),
        _ => format!("{}k", (count + 500) / 1000),
    }
 }
--- a/crates/assistant_eval/Cargo.toml
+++ b/crates/assistant_eval/Cargo.toml
@@ -13,8 +13,8 @@ name = "assistant_eval"
 path = "src/main.rs"

 [dependencies]
-agent.workspace = true
 anyhow.workspace = true
+assistant2.workspace = true
 assistant_tool.workspace = true
 assistant_tools.workspace = true
 clap.workspace = true
@@ -27,12 +27,14 @@ fs.workspace = true
 futures.workspace = true
 gpui.workspace = true
 gpui_tokio.workspace = true
+itertools.workspace = true
 language.workspace = true
 language_model.workspace = true
 language_models.workspace = true
 node_runtime.workspace = true
 project.workspace = true
 prompt_store.workspace = true
+regex.workspace = true
 release_channel.workspace = true
 reqwest_client.workspace = true
 serde.workspace = true
@@ -40,7 +42,4 @@ serde_json.workspace = true
 serde_json_lenient.workspace = true
 settings.workspace = true
 smol.workspace = true
-tempfile.workspace = true
 util.workspace = true
-walkdir.workspace = true
-workspace-hack.workspace = true
--- a/crates/assistant_eval/README.md
+++ b/crates/assistant_eval/README.md
@@ -1,25 +1,34 @@
 # Tool Evals

-A framework for evaluating and benchmarking the agent panel generations.
+A framework for evaluating and benchmarking AI assistant performance in the Zed editor.

 ## Overview

 Tool Evals provides a headless environment for running assistants evaluations on code repositories. It automates the process of:

-1. Setting up test code and repositories
+1. Cloning and setting up test repositories
 2. Sending prompts to language models
 3. Allowing the assistant to use tools to modify code
-4. Collecting metrics on performance and tool usage
+4. Collecting metrics on performance
 5. Evaluating results against known good solutions

 ## How It Works

 The system consists of several key components:

- **Eval**: Loads exercises from the zed-ace-framework repository, creates temporary repos, and executes evaluations
+- **Eval**: Loads test cases from the evaluation_data directory, clones repos, and executes evaluations
 - **HeadlessAssistant**: Provides a headless environment for running the AI assistant
- **Judge**: Evaluates AI-generated solutions against reference implementations and assigns scores
- **Templates**: Defines evaluation frameworks for different tasks (Project Creation, Code Modification, Conversational Guidance)
+- **Judge**: Compares AI-generated diffs with reference solutions and scores their functional similarity
+
+The evaluation flow:
+1. An evaluation is loaded from the evaluation_data directory
+2. The target repository is cloned and checked out at a specific commit
+3. A HeadlessAssistant instance is created with the specified language model
+4. The user prompt is sent to the assistant
+5. The assistant responds and uses tools to modify code
+6. Upon completion, a diff is generated from the changes
+7. Results are saved including the diff, assistant's response, and performance metrics
+8. If a reference solution exists, a Judge evaluates the similarity of the solution

 ## Setup Requirements

@@ -27,7 +36,6 @@ The system consists of several key components:

 - Rust and Cargo
 - Git
- Python (for report generation)
 - Network access to clone repositories
 - Appropriate API keys for language models and git services (Anthropic, GitHub, etc.)

@@ -35,34 +43,35 @@ The system consists of several key components:

 Ensure you have the required API keys set, either from a dev run of Zed or via these environment variables:
 - `ZED_ANTHROPIC_API_KEY` for Claude models
+- `ZED_OPENAI_API_KEY` for OpenAI models
 - `ZED_GITHUB_API_KEY` for GitHub API (or similar)

 ## Usage

-### Running Evaluations
+### Running a Single Evaluation
+
+To run a specific evaluation:

 ```bash
-# Run all tests
-cargo run -p assistant_eval -- --all
-
-# Run only specific languages
-cargo run -p assistant_eval -- --all --languages python,rust
-
-# Limit concurrent evaluations
-cargo run -p assistant_eval -- --all --concurrency 5
-
-# Limit number of exercises per language
-cargo run -p assistant_eval -- --all --max-exercises-per-language 3
+cargo run -p assistant_eval -- bubbletea-add-set-window-title
 ```

-### Evaluation Template Types
+The arguments are regex patterns for the evaluation names to run, so to run all evaluations that contain `bubbletea`, run:

-The system supports three types of evaluation templates:
+```bash
+cargo run -p assistant_eval -- bubbletea
+```

-1. **ProjectCreation**: Tests the model's ability to create new implementations from scratch
-2. **CodeModification**: Tests the model's ability to modify existing code to meet new requirements
-3. **ConversationalGuidance**: Tests the model's ability to provide guidance without writing code
+To run all evaluations:

-### Support Repo
+```bash
+cargo run -p assistant_eval -- --all
+```

-The [zed-industries/zed-ace-framework](https://github.com/zed-industries/zed-ace-framework) contains the analytics and reporting scripts.
+## Evaluation Data Structure
+
+Each evaluation should be placed in the `evaluation_data` directory with the following structure:
+
+* `prompt.txt`: The user's prompt.
+* `original.diff`: The `git diff` of the change anticipated for this prompt.
+* `setup.json`: Information about the repo used for the evaluation.
--- a/crates/assistant_eval/src/eval.rs
+++ b/crates/assistant_eval/src/eval.rs
@@ -1,8 +1,6 @@
-use crate::git_commands::{run_git, setup_temp_repo};
 use crate::headless_assistant::{HeadlessAppState, HeadlessAssistant};
-use crate::{get_exercise_language, get_exercise_name, templates_eval::Template};
-use agent::RequestKind;
-use anyhow::{Result, anyhow};
+use anyhow::anyhow;
+use assistant2::RequestKind;
 use collections::HashMap;
 use gpui::{App, Task};
 use language_model::{LanguageModel, TokenUsage};
@@ -12,26 +10,19 @@ use std::{
    io::Write,
    path::{Path, PathBuf},
    sync::Arc,
-    time::{Duration, SystemTime},
+    time::Duration,
 };
+use util::command::new_smol_command;

-#[derive(Debug, Serialize, Deserialize, Clone)]
-pub struct EvalResult {
-    pub exercise_name: String,
-    pub template_name: String,
-    pub score: String,
-    pub diff: String,
-    pub assistant_response: String,
-    pub elapsed_time_ms: u128,
-    pub timestamp: u128,
-    // Token usage fields
-    pub input_tokens: usize,
-    pub output_tokens: usize,
-    pub total_tokens: usize,
-    pub tool_use_counts: usize,
-    pub judge_model_name: String, // Added field for judge model name
+pub struct Eval {
+    pub name: String,
+    pub path: PathBuf,
+    pub repo_path: PathBuf,
+    pub eval_setup: EvalSetup,
+    pub user_prompt: String,
 }

+#[derive(Debug, Serialize)]
 pub struct EvalOutput {
    pub diff: String,
    pub last_message: String,
@@ -47,31 +38,19 @@ pub struct EvalSetup {
    pub base_sha: String,
 }

-pub struct Eval {
-    pub repo_path: PathBuf,
-    pub eval_setup: EvalSetup,
-    pub user_prompt: String,
-}
-
 impl Eval {
-    // Keep this method for potential future use, but mark it as intentionally unused
-    #[allow(dead_code)]
-    pub async fn load(_name: String, path: PathBuf, repos_dir: &Path) -> Result<Self> {
+    /// Loads the eval from a path (typically in `evaluation_data`). Clones and checks out the repo
+    /// if necessary.
+    pub async fn load(name: String, path: PathBuf, repos_dir: &Path) -> anyhow::Result<Self> {
        let prompt_path = path.join("prompt.txt");
        let user_prompt = smol::unblock(|| std::fs::read_to_string(prompt_path)).await?;
        let setup_path = path.join("setup.json");
        let setup_contents = smol::unblock(|| std::fs::read_to_string(setup_path)).await?;
        let eval_setup = serde_json_lenient::from_str_lenient::<EvalSetup>(&setup_contents)?;
-
-        // Move this internal function inside the load method since it's only used here
-        fn repo_dir_name(url: &str) -> String {
-            url.trim_start_matches("https://")
-                .replace(|c: char| !c.is_alphanumeric(), "_")
-        }
-
        let repo_path = repos_dir.join(repo_dir_name(&eval_setup.url));
-
        Ok(Eval {
+            name,
+            path,
            repo_path,
            eval_setup,
            user_prompt,
@@ -83,9 +62,9 @@ impl Eval {
        app_state: Arc<HeadlessAppState>,
        model: Arc<dyn LanguageModel>,
        cx: &mut App,
-    ) -> Task<Result<EvalOutput>> {
+    ) -> Task<anyhow::Result<EvalOutput>> {
        cx.spawn(async move |cx| {
-            run_git(&self.repo_path, &["checkout", &self.eval_setup.base_sha]).await?;
+            checkout_repo(&self.eval_setup, &self.repo_path).await?;

            let (assistant, done_rx) =
                cx.update(|cx| HeadlessAssistant::new(app_state.clone(), cx))??;
@@ -125,43 +104,9 @@ impl Eval {

            done_rx.recv().await??;

-            // Add this section to check untracked files
-            println!("Checking for untracked files:");
-            let untracked = run_git(
-                &self.repo_path,
-                &["ls-files", "--others", "--exclude-standard"],
-            )
-            .await?;
-            if untracked.is_empty() {
-                println!("No untracked files found");
-            } else {
-                // Add all files to git so they appear in the diff
-                println!("Adding untracked files to git");
-                run_git(&self.repo_path, &["add", "."]).await?;
-            }
-
-            // get git status
-            let _status = run_git(&self.repo_path, &["status", "--short"]).await?;
-
            let elapsed_time = start_time.elapsed()?;

-            // Get diff of staged changes (the files we just added)
-            let staged_diff = run_git(&self.repo_path, &["diff", "--staged"]).await?;
-
-            // Get diff of unstaged changes
-            let unstaged_diff = run_git(&self.repo_path, &["diff"]).await?;
-
-            // Combine both diffs
-            let diff = if unstaged_diff.is_empty() {
-                staged_diff
-            } else if staged_diff.is_empty() {
-                unstaged_diff
-            } else {
-                format!(
-                    "# Staged changes\n{}\n\n# Unstaged changes\n{}",
-                    staged_diff, unstaged_diff
-                )
-            };
+            let diff = query_git(&self.repo_path, vec!["diff"]).await?;

            assistant.update(cx, |assistant, cx| {
                let thread = assistant.thread.read(cx);
@@ -187,9 +132,12 @@ impl Eval {
 }

 impl EvalOutput {
-    // Keep this method for potential future use, but mark it as intentionally unused
-    #[allow(dead_code)]
-    pub fn save_to_directory(&self, output_dir: &Path, eval_output_value: String) -> Result<()> {
+    // Method to save the output to a directory
+    pub fn save_to_directory(
+        &self,
+        output_dir: &Path,
+        eval_output_value: String,
+    ) -> anyhow::Result<()> {
        // Create the output directory if it doesn't exist
        fs::create_dir_all(&output_dir)?;

@@ -244,305 +192,76 @@ impl EvalOutput {
    }
 }

-pub async fn read_instructions(exercise_path: &Path) -> Result<String> {
-    let instructions_path = exercise_path.join(".docs").join("instructions.md");
-    println!("Reading instructions from: {}", instructions_path.display());
-    let instructions = smol::unblock(move || std::fs::read_to_string(&instructions_path)).await?;
-    Ok(instructions)
+fn repo_dir_name(url: &str) -> String {
+    url.trim_start_matches("https://")
+        .replace(|c: char| !c.is_alphanumeric(), "_")
 }

-pub async fn read_example_solution(exercise_path: &Path, language: &str) -> Result<String> {
-    // Map the language to the file extension
-    let language_extension = match language {
-        "python" => "py",
-        "go" => "go",
-        "rust" => "rs",
-        "typescript" => "ts",
-        "javascript" => "js",
-        "ruby" => "rb",
-        "php" => "php",
-        "bash" => "sh",
-        "multi" => "diff",
-        "internal" => "diff",
-        _ => return Err(anyhow!("Unsupported language: {}", language)),
-    };
-    let example_path = exercise_path
-        .join(".meta")
-        .join(format!("example.{}", language_extension));
-    println!("Reading example solution from: {}", example_path.display());
-    let example = smol::unblock(move || std::fs::read_to_string(&example_path)).await?;
-    Ok(example)
-}
-
-pub async fn save_eval_results(exercise_path: &Path, results: Vec<EvalResult>) -> Result<()> {
-    let eval_dir = exercise_path.join("evaluation");
-    fs::create_dir_all(&eval_dir)?;
-
-    let eval_file = eval_dir.join("evals.json");
-
-    println!("Saving evaluation results to: {}", eval_file.display());
-    println!(
-        "Results to save: {} evaluations for exercise path: {}",
-        results.len(),
-        exercise_path.display()
-    );
-
-    // Check file existence before reading/writing
-    if eval_file.exists() {
-        println!("Existing evals.json file found, will update it");
+async fn checkout_repo(eval_setup: &EvalSetup, repo_path: &Path) -> anyhow::Result<()> {
+    if !repo_path.exists() {
+        smol::unblock({
+            let repo_path = repo_path.to_path_buf();
+            || std::fs::create_dir_all(repo_path)
+        })
+        .await?;
+        run_git(repo_path, vec!["init"]).await?;
+        run_git(repo_path, vec!["remote", "add", "origin", &eval_setup.url]).await?;
    } else {
-        println!("No existing evals.json file found, will create new one");
-    }
-
-    // Structure to organize evaluations by test name and timestamp
-    let mut eval_data: serde_json::Value = if eval_file.exists() {
-        let content = fs::read_to_string(&eval_file)?;
-        serde_json::from_str(&content).unwrap_or_else(|_| serde_json::json!({}))
-    } else {
-        serde_json::json!({})
-    };
-
-    // Get current timestamp for this batch of results
-    let timestamp = SystemTime::now()
-        .duration_since(SystemTime::UNIX_EPOCH)?
-        .as_millis()
-        .to_string();
-
-    // Group the new results by test name (exercise name)
-    for result in results {
-        let exercise_name = &result.exercise_name;
-        let template_name = &result.template_name;
-
-        println!(
-            "Adding result: exercise={}, template={}",
-            exercise_name, template_name
-        );
-
-        // Ensure the exercise entry exists
-        if eval_data.get(exercise_name).is_none() {
-            eval_data[exercise_name] = serde_json::json!({});
+        let actual_origin = query_git(repo_path, vec!["remote", "get-url", "origin"]).await?;
+        if actual_origin != eval_setup.url {
+            return Err(anyhow!(
+                "remote origin {} does not match expected origin {}",
+                actual_origin,
+                eval_setup.url
+            ));
        }

-        // Ensure the timestamp entry exists as an object
-        if eval_data[exercise_name].get(&timestamp).is_none() {
-            eval_data[exercise_name][&timestamp] = serde_json::json!({});
-        }
-
-        // Add this result under the timestamp with template name as key
-        eval_data[exercise_name][&timestamp][template_name] = serde_json::to_value(&result)?;
+        // TODO: consider including "-x" to remove ignored files. The downside of this is that it will
+        // also remove build artifacts, and so prevent incremental reuse there.
+        run_git(repo_path, vec!["clean", "--force", "-d"]).await?;
+        run_git(repo_path, vec!["reset", "--hard", "HEAD"]).await?;
    }

-    // Write back to file with pretty formatting
-    let json_content = serde_json::to_string_pretty(&eval_data)?;
-    match fs::write(&eval_file, json_content) {
-        Ok(_) => println!("✓ Successfully saved results to {}", eval_file.display()),
-        Err(e) => println!("✗ Failed to write results file: {}", e),
-    }
+    run_git(
+        repo_path,
+        vec!["fetch", "--depth", "1", "origin", &eval_setup.base_sha],
+    )
+    .await?;
+    run_git(repo_path, vec!["checkout", &eval_setup.base_sha]).await?;

    Ok(())
 }

-pub async fn run_exercise_eval(
-    exercise_path: PathBuf,
-    template: Template,
-    model: Arc<dyn LanguageModel>,
-    judge_model: Arc<dyn LanguageModel>,
-    app_state: Arc<HeadlessAppState>,
-    base_sha: String,
-    _framework_path: PathBuf,
-    cx: gpui::AsyncApp,
-) -> Result<EvalResult> {
-    let exercise_name = get_exercise_name(&exercise_path);
-    let language = get_exercise_language(&exercise_path)?;
-    let mut instructions = read_instructions(&exercise_path).await?;
-    instructions.push_str(&format!(
-        "\n\nWhen writing the code for this prompt, use {} to achieve the goal.",
-        language
-    ));
-    let example_solution = read_example_solution(&exercise_path, &language).await?;
-
-    println!(
-        "Running evaluation for exercise: {} with template: {}",
-        exercise_name, template.name
-    );
-
-    // Create temporary directory with exercise files
-    let temp_dir = setup_temp_repo(&exercise_path, &base_sha).await?;
-    let temp_path = temp_dir.path().to_path_buf();
-
-    if template.name == "ProjectCreation" {
-        for entry in fs::read_dir(&temp_path)? {
-            let entry = entry?;
-            let path = entry.path();
-
-            // Skip directories that start with dot (like .docs, .meta, .git)
-            if path.is_dir()
-                && path
-                    .file_name()
-                    .and_then(|name| name.to_str())
-                    .map(|name| name.starts_with("."))
-                    .unwrap_or(false)
-            {
-                continue;
-            }
-
-            // Delete regular files
-            if path.is_file() {
-                println!("  Deleting file: {}", path.display());
-                fs::remove_file(path)?;
-            }
-        }
-
-        // Commit the deletion so it shows up in the diff
-        run_git(&temp_path, &["add", "."]).await?;
-        run_git(
-            &temp_path,
-            &["commit", "-m", "Remove root files for clean slate"],
-        )
+async fn run_git(repo_path: &Path, args: Vec<&str>) -> anyhow::Result<()> {
+    let exit_status = new_smol_command("git")
+        .current_dir(repo_path)
+        .args(args.clone())
+        .status()
        .await?;
-    }
-
-    let local_commit_sha = run_git(&temp_path, &["rev-parse", "HEAD"]).await?;
-
-    // Prepare prompt based on template
-    let prompt = match template.name {
-        "ProjectCreation" => format!(
-            "I need to create a new implementation for this exercise. Please create all the necessary files in the best location.\n\n{}",
-            instructions
-        ),
-        "CodeModification" => format!(
-            "I need help updating my code to meet these requirements. Please modify the appropriate files:\n\n{}",
-            instructions
-        ),
-        "ConversationalGuidance" => format!(
-            "I'm trying to solve this coding exercise but I'm not sure where to start. Can you help me understand the requirements and guide me through the solution process without writing code for me?\n\n{}",
-            instructions
-        ),
-        _ => instructions.clone(),
-    };
-
-    let start_time = SystemTime::now();
-
-    // Create a basic eval struct to work with the existing system
-    let eval = Eval {
-        repo_path: temp_path.clone(),
-        eval_setup: EvalSetup {
-            url: format!("file://{}", temp_path.display()),
-            base_sha: local_commit_sha, // Use the local commit SHA instead of the framework base SHA
-        },
-        user_prompt: prompt,
-    };
-
-    // Run the evaluation
-    let eval_output = cx
-        .update(|cx| eval.run(app_state.clone(), model.clone(), cx))?
-        .await?;
-
-    // Get diff from git
-    let diff = eval_output.diff.clone();
-
-    // For project creation template, we need to compare with reference implementation
-    let judge_output = if template.name == "ProjectCreation" {
-        let project_judge_prompt = template
-            .content
-            .replace(
-                "<!-- ```requirements go here``` -->",
-                &format!("```\n{}\n```", instructions),
-            )
-            .replace(
-                "<!-- ```reference code goes here``` -->",
-                &format!("```{}\n{}\n```", language, example_solution),
-            )
-            .replace(
-                "<!-- ```git diff goes here``` -->",
-                &format!("```\n{}\n```", diff),
-            );
-
-        // Use the run_with_prompt method which we'll add to judge.rs
-        let judge = crate::judge::Judge {
-            original_diff: None,
-            original_message: Some(project_judge_prompt),
-            model: judge_model.clone(),
-        };
-
-        cx.update(|cx| judge.run_with_prompt(cx))?.await?
-    } else if template.name == "CodeModification" {
-        // For CodeModification, we'll compare the example solution with the LLM-generated solution
-        let code_judge_prompt = template
-            .content
-            .replace(
-                "<!-- ```reference code goes here``` -->",
-                &format!("```{}\n{}\n```", language, example_solution),
-            )
-            .replace(
-                "<!-- ```git diff goes here``` -->",
-                &format!("```\n{}\n```", diff),
-            );
-
-        // Use the run_with_prompt method
-        let judge = crate::judge::Judge {
-            original_diff: None,
-            original_message: Some(code_judge_prompt),
-            model: judge_model.clone(),
-        };
-
-        cx.update(|cx| judge.run_with_prompt(cx))?.await?
+    if exit_status.success() {
+        Ok(())
    } else {
-        // Conversational template
-        let conv_judge_prompt = template
-            .content
-            .replace(
-                "<!-- ```query goes here``` -->",
-                &format!("```\n{}\n```", instructions),
-            )
-            .replace(
-                "<!-- ```transcript goes here``` -->",
-                &format!("```\n{}\n```", eval_output.last_message),
-            )
-            .replace(
-                "<!-- ```git diff goes here``` -->",
-                &format!("```\n{}\n```", diff),
-            );
-
-        // Use the run_with_prompt method for consistency
-        let judge = crate::judge::Judge {
-            original_diff: None,
-            original_message: Some(conv_judge_prompt),
-            model: judge_model.clone(),
-        };
-
-        cx.update(|cx| judge.run_with_prompt(cx))?.await?
-    };
-
-    let elapsed_time = start_time.elapsed()?;
-
-    // Calculate total tokens as the sum of input and output tokens
-    let input_tokens = eval_output.token_usage.input_tokens;
-    let output_tokens = eval_output.token_usage.output_tokens;
-    let tool_use_counts = eval_output.tool_use_counts.values().sum::<u32>();
-    let total_tokens = input_tokens + output_tokens;
-
-    // Get judge model name
-    let judge_model_name = judge_model.id().0.to_string();
-
-    // Save results to evaluation directory
-    let result = EvalResult {
-        exercise_name: exercise_name.clone(),
-        template_name: template.name.to_string(),
-        score: judge_output.trim().to_string(),
-        diff,
-        assistant_response: eval_output.last_message.clone(),
-        elapsed_time_ms: elapsed_time.as_millis(),
-        timestamp: SystemTime::now()
-            .duration_since(SystemTime::UNIX_EPOCH)?
-            .as_millis(),
-        // Convert u32 token counts to usize
-        input_tokens: input_tokens.try_into().unwrap(),
-        output_tokens: output_tokens.try_into().unwrap(),
-        total_tokens: total_tokens.try_into().unwrap(),
-        tool_use_counts: tool_use_counts.try_into().unwrap(),
-        judge_model_name, // Add judge model name to result
-    };
-
-    Ok(result)
+        Err(anyhow!(
+            "`git {}` failed with {}",
+            args.join(" "),
+            exit_status,
+        ))
+    }
+}
+
+async fn query_git(repo_path: &Path, args: Vec<&str>) -> anyhow::Result<String> {
+    let output = new_smol_command("git")
+        .current_dir(repo_path)
+        .args(args.clone())
+        .output()
+        .await?;
+    if output.status.success() {
+        Ok(String::from_utf8(output.stdout)?.trim().to_string())
+    } else {
+        Err(anyhow!(
+            "`git {}` failed with {}",
+            args.join(" "),
+            output.status
+        ))
+    }
 }
--- a/crates/assistant_eval/src/get_exercise.rs
+++ b/crates/assistant_eval/src/get_exercise.rs
@@ -1,149 +0,0 @@
-use anyhow::{Result, anyhow};
-use std::{
-    fs,
-    path::{Path, PathBuf},
-};
-
-pub fn get_exercise_name(exercise_path: &Path) -> String {
-    exercise_path
-        .file_name()
-        .unwrap_or_default()
-        .to_string_lossy()
-        .to_string()
-}
-
-pub fn get_exercise_language(exercise_path: &Path) -> Result<String> {
-    // Extract the language from path (data/python/exercises/... => python)
-    let parts: Vec<_> = exercise_path.components().collect();
-
-    for (i, part) in parts.iter().enumerate() {
-        if i > 0 && part.as_os_str() == "eval_code" {
-            if i + 1 < parts.len() {
-                let language = parts[i + 1].as_os_str().to_string_lossy().to_string();
-                return Ok(language);
-            }
-        }
-    }
-
-    Err(anyhow!(
-        "Could not determine language from path: {:?}",
-        exercise_path
-    ))
-}
-
-pub fn find_exercises(
-    framework_path: &Path,
-    languages: &[&str],
-    max_per_language: Option<usize>,
-) -> Result<Vec<PathBuf>> {
-    let mut all_exercises = Vec::new();
-
-    println!("Searching for exercises in languages: {:?}", languages);
-
-    for language in languages {
-        let language_dir = framework_path
-            .join("eval_code")
-            .join(language)
-            .join("exercises")
-            .join("practice");
-
-        println!("Checking language directory: {:?}", language_dir);
-        if !language_dir.exists() {
-            println!("Warning: Language directory not found: {:?}", language_dir);
-            continue;
-        }
-
-        let mut exercises = Vec::new();
-        match fs::read_dir(&language_dir) {
-            Ok(entries) => {
-                for entry_result in entries {
-                    match entry_result {
-                        Ok(entry) => {
-                            let path = entry.path();
-
-                            if path.is_dir() {
-                                // Special handling for "internal" directory
-                                if *language == "internal" {
-                                    // Check for repo_info.json to validate it's an internal exercise
-                                    let repo_info_path = path.join(".meta").join("repo_info.json");
-                                    let instructions_path =
-                                        path.join(".docs").join("instructions.md");
-
-                                    if repo_info_path.exists() && instructions_path.exists() {
-                                        exercises.push(path);
-                                    }
-                                } else {
-                                    // Map the language to the file extension - original code
-                                    let language_extension = match *language {
-                                        "python" => "py",
-                                        "go" => "go",
-                                        "rust" => "rs",
-                                        "typescript" => "ts",
-                                        "javascript" => "js",
-                                        "ruby" => "rb",
-                                        "php" => "php",
-                                        "bash" => "sh",
-                                        "multi" => "diff",
-                                        _ => continue, // Skip unsupported languages
-                                    };
-
-                                    // Check if this is a valid exercise with instructions and example
-                                    let instructions_path =
-                                        path.join(".docs").join("instructions.md");
-                                    let has_instructions = instructions_path.exists();
-                                    let example_path = path
-                                        .join(".meta")
-                                        .join(format!("example.{}", language_extension));
-                                    let has_example = example_path.exists();
-
-                                    if has_instructions && has_example {
-                                        exercises.push(path);
-                                    }
-                                }
-                            }
-                        }
-                        Err(err) => println!("Error reading directory entry: {}", err),
-                    }
-                }
-            }
-            Err(err) => println!(
-                "Error reading directory {}: {}",
-                language_dir.display(),
-                err
-            ),
-        }
-
-        // Sort exercises by name for consistent selection
-        exercises.sort_by(|a, b| {
-            let a_name = a.file_name().unwrap_or_default().to_string_lossy();
-            let b_name = b.file_name().unwrap_or_default().to_string_lossy();
-            a_name.cmp(&b_name)
-        });
-
-        // Apply the limit if specified
-        if let Some(limit) = max_per_language {
-            if exercises.len() > limit {
-                println!(
-                    "Limiting {} exercises to {} for language {}",
-                    exercises.len(),
-                    limit,
-                    language
-                );
-                exercises.truncate(limit);
-            }
-        }
-
-        println!(
-            "Found {} exercises for language {}: {:?}",
-            exercises.len(),
-            language,
-            exercises
-                .iter()
-                .map(|p| p.file_name().unwrap_or_default().to_string_lossy())
-                .collect::<Vec<_>>()
-        );
-        all_exercises.extend(exercises);
-    }
-
-    Ok(all_exercises)
-}
--- a/crates/assistant_eval/src/git_commands.rs
+++ b/crates/assistant_eval/src/git_commands.rs
@@ -1,125 +0,0 @@
-use anyhow::{Result, anyhow};
-use serde::Deserialize;
-use std::{fs, path::Path};
-use tempfile::TempDir;
-use util::command::new_smol_command;
-use walkdir::WalkDir;
-
-#[derive(Debug, Deserialize)]
-pub struct SetupConfig {
-    #[serde(rename = "base.sha")]
-    pub base_sha: String,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct RepoInfo {
-    pub remote_url: String,
-    pub head_sha: String,
-}
-
-pub async fn run_git(repo_path: &Path, args: &[&str]) -> Result<String> {
-    let output = new_smol_command("git")
-        .current_dir(repo_path)
-        .args(args)
-        .output()
-        .await?;
-
-    if output.status.success() {
-        Ok(String::from_utf8(output.stdout)?.trim().to_string())
-    } else {
-        Err(anyhow!(
-            "Git command failed: {} with status: {}",
-            args.join(" "),
-            output.status
-        ))
-    }
-}
-
-pub async fn read_base_sha(framework_path: &Path) -> Result<String> {
-    let setup_path = framework_path.join("setup.json");
-    let setup_content = smol::unblock(move || std::fs::read_to_string(&setup_path)).await?;
-    let setup_config: SetupConfig = serde_json_lenient::from_str_lenient(&setup_content)?;
-    Ok(setup_config.base_sha)
-}
-
-pub async fn read_repo_info(exercise_path: &Path) -> Result<RepoInfo> {
-    let repo_info_path = exercise_path.join(".meta").join("repo_info.json");
-    println!("Reading repo info from: {}", repo_info_path.display());
-    let repo_info_content = smol::unblock(move || std::fs::read_to_string(&repo_info_path)).await?;
-    let repo_info: RepoInfo = serde_json_lenient::from_str_lenient(&repo_info_content)?;
-
-    // Remove any quotes from the strings
-    let remote_url = repo_info.remote_url.trim_matches('"').to_string();
-    let head_sha = repo_info.head_sha.trim_matches('"').to_string();
-
-    Ok(RepoInfo {
-        remote_url,
-        head_sha,
-    })
-}
-
-pub async fn setup_temp_repo(exercise_path: &Path, _base_sha: &str) -> Result<TempDir> {
-    let temp_dir = TempDir::new()?;
-
-    // Check if this is an internal exercise by looking for repo_info.json
-    let repo_info_path = exercise_path.join(".meta").join("repo_info.json");
-    if repo_info_path.exists() {
-        // This is an internal exercise, handle it differently
-        let repo_info = read_repo_info(exercise_path).await?;
-
-        // Clone the repository to the temp directory
-        let url = repo_info.remote_url;
-        let clone_path = temp_dir.path();
-        println!(
-            "Cloning repository from {} to {}",
-            url,
-            clone_path.display()
-        );
-        run_git(
-            &std::env::current_dir()?,
-            &["clone", &url, &clone_path.to_string_lossy()],
-        )
-        .await?;
-
-        // Checkout the specified commit
-        println!("Checking out commit: {}", repo_info.head_sha);
-        run_git(temp_dir.path(), &["checkout", &repo_info.head_sha]).await?;
-
-        println!("Successfully set up internal repository");
-    } else {
-        // Original code for regular exercises
-        // Copy the exercise files to the temp directory, excluding .docs and .meta
-        for entry in WalkDir::new(exercise_path).min_depth(0).max_depth(10) {
-            let entry = entry?;
-            let source_path = entry.path();
-
-            // Skip .docs and .meta directories completely
-            if source_path.starts_with(exercise_path.join(".docs"))
-                || source_path.starts_with(exercise_path.join(".meta"))
-            {
-                continue;
-            }
-
-            if source_path.is_file() {
-                let relative_path = source_path.strip_prefix(exercise_path)?;
-                let dest_path = temp_dir.path().join(relative_path);
-
-                // Make sure parent directories exist
-                if let Some(parent) = dest_path.parent() {
-                    fs::create_dir_all(parent)?;
-                }
-
-                fs::copy(source_path, dest_path)?;
-            }
-        }
-
-        // Initialize git repo in the temp directory
-        run_git(temp_dir.path(), &["init"]).await?;
-        run_git(temp_dir.path(), &["add", "."]).await?;
-        run_git(temp_dir.path(), &["commit", "-m", "Initial commit"]).await?;
-
-        println!("Created temp repo without .docs and .meta directories");
-    }
-
-    Ok(temp_dir)
-}
--- a/crates/assistant_eval/src/headless_assistant.rs
+++ b/crates/assistant_eval/src/headless_assistant.rs
@@ -1,6 +1,6 @@
-use agent::{RequestKind, Thread, ThreadEvent, ThreadStore};
 use anyhow::anyhow;
 use assistant_tool::ToolWorkingSet;
+use assistant2::{RequestKind, Thread, ThreadEvent, ThreadStore};
 use client::{Client, UserStore};
 use collections::HashMap;
 use dap::DapRegistry;
@@ -102,40 +102,6 @@ impl HeadlessAssistant {
                    thread.use_pending_tools(cx);
                });
            }
-            ThreadEvent::ToolConfirmationNeeded => {
-                // Automatically approve all tools that need confirmation in headless mode
-                println!("Tool confirmation needed - automatically approving in headless mode");
-
-                // Get the tools needing confirmation
-                let tools_needing_confirmation: Vec<_> = thread
-                    .read(cx)
-                    .tools_needing_confirmation()
-                    .cloned()
-                    .collect();
-
-                // Run each tool that needs confirmation
-                for tool_use in tools_needing_confirmation {
-                    if let Some(tool) = thread.read(cx).tools().tool(&tool_use.name, cx) {
-                        thread.update(cx, |thread, cx| {
-                            println!("Auto-approving tool: {}", tool_use.name);
-
-                            // Create a request to send to the tool
-                            let request = thread.to_completion_request(RequestKind::Chat, cx);
-                            let messages = Arc::new(request.messages);
-
-                            // Run the tool
-                            thread.run_tool(
-                                tool_use.id.clone(),
-                                tool_use.ui_text.clone(),
-                                tool_use.input.clone(),
-                                &messages,
-                                tool,
-                                cx,
-                            );
-                        });
-                    }
-                }
-            }
            ThreadEvent::ToolFinished {
                tool_use_id,
                pending_tool_use,
@@ -156,15 +122,11 @@ impl HeadlessAssistant {
                }
                if thread.read(cx).all_tools_finished() {
                    let model_registry = LanguageModelRegistry::read_global(cx);
-                    if let Some(model) = model_registry.default_model() {
+                    if let Some(model) = model_registry.active_model() {
                        thread.update(cx, |thread, cx| {
-                            thread.attach_tool_results(cx);
-                            thread.send_to_model(model.model, RequestKind::Chat, cx);
+                            thread.attach_tool_results(vec![], cx);
+                            thread.send_to_model(model, RequestKind::Chat, cx);
                        });
-                    } else {
-                        println!(
-                            "Warning: No active language model available to continue conversation"
-                        );
                    }
                }
            }
@@ -205,7 +167,7 @@ pub fn init(cx: &mut App) -> Arc<HeadlessAppState> {
    context_server::init(cx);
    let stdout_is_a_pty = false;
    let prompt_builder = PromptBuilder::load(fs.clone(), stdout_is_a_pty, cx);
-    agent::init(fs.clone(), client.clone(), prompt_builder.clone(), cx);
+    assistant2::init(fs.clone(), client.clone(), prompt_builder.clone(), cx);

    Arc::new(HeadlessAppState {
        languages,
--- a/crates/assistant_eval/src/judge.rs
+++ b/crates/assistant_eval/src/judge.rs
@@ -1,28 +1,58 @@
+use crate::eval::EvalOutput;
 use crate::headless_assistant::send_language_model_request;
 use anyhow::anyhow;
 use gpui::{App, Task};
 use language_model::{
    LanguageModel, LanguageModelRequest, LanguageModelRequestMessage, MessageContent, Role,
 };
-use std::sync::Arc;
+use std::{path::Path, sync::Arc};

 pub struct Judge {
-    #[allow(dead_code)]
    pub original_diff: Option<String>,
+    #[allow(dead_code)]
    pub original_message: Option<String>,
    pub model: Arc<dyn LanguageModel>,
 }

 impl Judge {
-    pub fn run_with_prompt(&self, cx: &mut App) -> Task<anyhow::Result<String>> {
-        let Some(prompt) = self.original_message.as_ref() else {
-            return Task::ready(Err(anyhow!("No prompt provided in original_message")));
+    pub async fn load(eval_path: &Path, model: Arc<dyn LanguageModel>) -> anyhow::Result<Judge> {
+        let original_diff_path = eval_path.join("original.diff");
+        let original_diff = smol::unblock(move || {
+            if std::fs::exists(&original_diff_path)? {
+                anyhow::Ok(Some(std::fs::read_to_string(&original_diff_path)?))
+            } else {
+                anyhow::Ok(None)
+            }
+        });
+
+        let original_message_path = eval_path.join("original_message.txt");
+        let original_message = smol::unblock(move || {
+            if std::fs::exists(&original_message_path)? {
+                anyhow::Ok(Some(std::fs::read_to_string(&original_message_path)?))
+            } else {
+                anyhow::Ok(None)
+            }
+        });
+
+        Ok(Self {
+            original_diff: original_diff.await?,
+            original_message: original_message.await?,
+            model,
+        })
+    }
+
+    pub fn run(&self, eval_output: &EvalOutput, cx: &mut App) -> Task<anyhow::Result<String>> {
+        let Some(original_diff) = self.original_diff.as_ref() else {
+            return Task::ready(Err(anyhow!("No original.diff found")));
        };

+        // TODO: check for empty diff?
+        let prompt = diff_comparison_prompt(&original_diff, &eval_output.diff);
+
        let request = LanguageModelRequest {
            messages: vec![LanguageModelRequestMessage {
                role: Role::User,
-                content: vec![MessageContent::Text(prompt.clone())],
+                content: vec![MessageContent::Text(prompt)],
                cache: false,
            }],
            temperature: Some(0.0),
@@ -31,7 +61,61 @@ impl Judge {
        };

        let model = self.model.clone();
-        let request = request.clone();
        cx.spawn(async move |cx| send_language_model_request(model, request, cx).await)
    }
 }
+
+pub fn diff_comparison_prompt(original_diff: &str, new_diff: &str) -> String {
+    format!(
+        r#"# Git Diff Similarity Evaluation Template
+
+## Instructions
+
+Compare the two diffs and score them between 0.0 and 1.0 based on their functional similarity.
+- 1.0 = Perfect functional match (achieves identical results)
+- 0.0 = No functional similarity whatsoever
+
+## Evaluation Criteria
+
+Please consider the following aspects in order of importance:
+
+1. **Functional Equivalence (60%)**
+   - Do both diffs achieve the same end result?
+   - Are the changes functionally equivalent despite possibly using different approaches?
+   - Do the modifications address the same issues or implement the same features?
+
+2. **Logical Structure (20%)**
+   - Are the logical flows similar?
+   - Do the modifications affect the same code paths?
+   - Are control structures (if/else, loops, etc.) modified in similar ways?
+
+3. **Code Content (15%)**
+   - Are similar lines added/removed?
+   - Are the same variables, functions, or methods being modified?
+   - Are the same APIs or libraries being used?
+
+4. **File Layout (5%)**
+   - Are the same files being modified?
+   - Are changes occurring in similar locations within files?
+
+## Input
+
+Original Diff:
+```git
+{}
+```
+
+New Diff:
+```git
+{}
+```
+
+## Output Format
+
+THE ONLY OUTPUT SHOULD BE A SCORE BETWEEN 0.0 AND 1.0.
+
+Example output:
+0.85"#,
+        original_diff, new_diff
+    )
+}
--- a/crates/assistant_eval/src/main.rs
+++ b/crates/assistant_eval/src/main.rs
@@ -1,21 +1,18 @@
 mod eval;
-mod get_exercise;
-mod git_commands;
 mod headless_assistant;
 mod judge;
-mod templates_eval;

 use clap::Parser;
-use eval::{run_exercise_eval, save_eval_results};
-use futures::stream::{self, StreamExt};
-use get_exercise::{find_exercises, get_exercise_language, get_exercise_name};
-use git_commands::read_base_sha;
-use gpui::Application;
-use headless_assistant::{authenticate_model_provider, find_model};
-use language_model::LanguageModelRegistry;
+use eval::{Eval, EvalOutput};
+use futures::future;
+use gpui::{Application, AsyncApp};
+use headless_assistant::{HeadlessAppState, authenticate_model_provider, find_model};
+use itertools::Itertools;
+use judge::Judge;
+use language_model::{LanguageModel, LanguageModelRegistry};
+use regex::Regex;
 use reqwest_client::ReqwestClient;
-use std::{path::PathBuf, sync::Arc};
-use templates_eval::all_templates;
+use std::{cmp, path::PathBuf, sync::Arc};

 #[derive(Parser, Debug)]
 #[command(
@@ -24,231 +21,204 @@ use templates_eval::all_templates;
    before_help = "Tool eval runner"
 )]
 struct Args {
-    /// Match the names of evals to run.
-    #[arg(long)]
-    exercise_names: Vec<String>,
-    /// Runs all exercises, causes the exercise_names to be ignored.
+    /// Regexes to match the names of evals to run.
+    eval_name_regexes: Vec<String>,
+    /// Runs all evals in `evaluation_data`, causes the regex to be ignored.
    #[arg(long)]
    all: bool,
-    /// Supported language types to evaluate (default: internal).
-    /// Internal is data generated from the agent panel
-    #[arg(long, default_value = "internal")]
-    languages: String,
    /// Name of the model (default: "claude-3-7-sonnet-latest")
    #[arg(long, default_value = "claude-3-7-sonnet-latest")]
    model_name: String,
+    /// Name of the editor model (default: value of `--model_name`).
+    #[arg(long)]
+    editor_model_name: Option<String>,
    /// Name of the judge model (default: value of `--model_name`).
    #[arg(long)]
    judge_model_name: Option<String>,
-    /// Number of evaluations to run concurrently (default: 3)
-    #[arg(short, long, default_value = "3")]
+    /// Number of evaluations to run concurrently (default: 10)
+    #[arg(short, long, default_value = "10")]
    concurrency: usize,
-    /// Maximum number of exercises to evaluate per language
-    #[arg(long)]
-    max_exercises_per_language: Option<usize>,
 }

-// First, let's define the order in which templates should be executed
-const TEMPLATE_EXECUTION_ORDER: [&str; 3] = [
-    "ProjectCreation",
-    "CodeModification",
-    "ConversationalGuidance",
-];
-
 fn main() {
    env_logger::init();
    let args = Args::parse();
    let http_client = Arc::new(ReqwestClient::new());
    let app = Application::headless().with_http_client(http_client.clone());

-    // Path to the zed-ace-framework repo
-    let framework_path = PathBuf::from("../zed-ace-framework")
-        .canonicalize()
-        .unwrap();
+    let crate_dir = PathBuf::from("../zed-agent-bench");
+    let evaluation_data_dir = crate_dir.join("evaluation_data").canonicalize().unwrap();

-    // Fix the 'languages' lifetime issue by creating owned Strings instead of slices
-    let languages: Vec<String> = args.languages.split(',').map(|s| s.to_string()).collect();
+    let repos_dir = crate_dir.join("repos");
+    if !repos_dir.exists() {
+        std::fs::create_dir_all(&repos_dir).unwrap();
+    }
+    let repos_dir = repos_dir.canonicalize().unwrap();

-    println!("Using zed-ace-framework at: {:?}", framework_path);
-    println!("Evaluating languages: {:?}", languages);
+    let all_evals = std::fs::read_dir(&evaluation_data_dir)
+        .unwrap()
+        .map(|path| path.unwrap().file_name().to_string_lossy().to_string())
+        .collect::<Vec<_>>();
+
+    let evals_to_run = if args.all {
+        all_evals
+    } else {
+        args.eval_name_regexes
+            .into_iter()
+            .map(|regex_string| Regex::new(&regex_string).unwrap())
+            .flat_map(|regex| {
+                all_evals
+                    .iter()
+                    .filter(|eval_name| regex.is_match(eval_name))
+                    .cloned()
+                    .collect::<Vec<_>>()
+            })
+            .collect::<Vec<_>>()
+    };
+
+    if evals_to_run.is_empty() {
+        panic!("Names of evals to run must be provided or `--all` specified");
+    }
+
+    println!("Will run the following evals: {evals_to_run:?}");
+    println!("Running up to {} evals concurrently", args.concurrency);
+
+    let editor_model_name = if let Some(model_name) = args.editor_model_name {
+        model_name
+    } else {
+        args.model_name.clone()
+    };
+
+    let judge_model_name = if let Some(model_name) = args.judge_model_name {
+        model_name
+    } else {
+        args.model_name.clone()
+    };

    app.run(move |cx| {
        let app_state = headless_assistant::init(cx);

        let model = find_model(&args.model_name, cx).unwrap();
-        let judge_model = if let Some(model_name) = &args.judge_model_name {
-            find_model(model_name, cx).unwrap()
-        } else {
-            model.clone()
-        };
+        let editor_model = find_model(&editor_model_name, cx).unwrap();
+        let judge_model = find_model(&judge_model_name, cx).unwrap();

        LanguageModelRegistry::global(cx).update(cx, |registry, cx| {
-            registry.set_default_model(Some(model.clone()), cx);
+            registry.set_active_model(Some(model.clone()), cx);
+            registry.set_editor_model(Some(editor_model.clone()), cx);
        });

        let model_provider_id = model.provider_id();
+        let editor_model_provider_id = editor_model.provider_id();
        let judge_model_provider_id = judge_model.provider_id();

-        let framework_path_clone = framework_path.clone();
-        let languages_clone = languages.clone();
-        let exercise_names = args.exercise_names.clone();
-        let all_flag = args.all;
-
        cx.spawn(async move |cx| {
            // Authenticate all model providers first
            cx.update(|cx| authenticate_model_provider(model_provider_id.clone(), cx))
                .unwrap()
                .await
                .unwrap();
+            cx.update(|cx| authenticate_model_provider(editor_model_provider_id.clone(), cx))
+                .unwrap()
+                .await
+                .unwrap();
            cx.update(|cx| authenticate_model_provider(judge_model_provider_id.clone(), cx))
                .unwrap()
                .await
                .unwrap();

-            // Read base SHA from setup.json
-            let base_sha = read_base_sha(&framework_path_clone).await.unwrap();
-
-            // Find all exercises for the specified languages
-            let all_exercises = find_exercises(
-                &framework_path_clone,
-                &languages_clone
-                    .iter()
-                    .map(|s| s.as_str())
-                    .collect::<Vec<_>>(),
-                args.max_exercises_per_language,
-            )
-            .unwrap();
-            println!("Found {} exercises total", all_exercises.len());
-
-            // Filter exercises if specific ones were requested
-            let exercises_to_run = if !exercise_names.is_empty() {
-                // If exercise names are specified, filter by them regardless of --all flag
-                all_exercises
-                    .into_iter()
-                    .filter(|path| {
-                        let name = get_exercise_name(path);
-                        exercise_names.iter().any(|filter| name.contains(filter))
-                    })
-                    .collect()
-            } else if all_flag {
-                // Only use all_flag if no exercise names are specified
-                all_exercises
-            } else {
-                // Default behavior (no filters)
-                all_exercises
-            };
-
-            println!("Will run {} exercises", exercises_to_run.len());
-
-            // Get all templates and sort them according to the execution order
-            let mut templates = all_templates();
-            templates.sort_by_key(|template| {
-                TEMPLATE_EXECUTION_ORDER
-                    .iter()
-                    .position(|&name| name == template.name)
-                    .unwrap_or(usize::MAX)
-            });
-
-            // Create exercise eval tasks - each exercise is a single task that will run templates sequentially
-            let exercise_tasks: Vec<_> = exercises_to_run
+            let eval_load_futures = evals_to_run
                .into_iter()
-                .map(|exercise_path| {
-                    let exercise_name = get_exercise_name(&exercise_path);
-                    let templates_clone = templates.clone();
-                    let model_clone = model.clone();
-                    let judge_model_clone = judge_model.clone();
-                    let app_state_clone = app_state.clone();
-                    let base_sha_clone = base_sha.clone();
-                    let framework_path_clone = framework_path_clone.clone();
-                    let cx_clone = cx.clone();
-
+                .map(|eval_name| {
+                    let eval_path = evaluation_data_dir.join(&eval_name);
+                    let load_future = Eval::load(eval_name.clone(), eval_path, &repos_dir);
                    async move {
-                        println!("Processing exercise: {}", exercise_name);
-                        let mut exercise_results = Vec::new();
-
-                        // Determine the language for this exercise
-                        let language = match get_exercise_language(&exercise_path) {
-                            Ok(lang) => lang,
+                        match load_future.await {
+                            Ok(eval) => Some(eval),
                            Err(err) => {
-                                println!(
-                                    "Error determining language for {}: {}",
-                                    exercise_name, err
-                                );
-                                return exercise_results;
-                            }
-                        };
-
-                        // Run each template sequentially for this exercise
-                        for template in templates_clone {
-                            // For "multi" or "internal" language, only run the CodeModification template
-                            if (language == "multi" || language == "internal")
-                                && template.name != "CodeModification"
-                            {
-                                println!(
-                                    "Skipping {} template for {} language",
-                                    template.name, language
-                                );
-                                continue;
-                            }
-
-                            match run_exercise_eval(
-                                exercise_path.clone(),
-                                template.clone(),
-                                model_clone.clone(),
-                                judge_model_clone.clone(),
-                                app_state_clone.clone(),
-                                base_sha_clone.clone(),
-                                framework_path_clone.clone(),
-                                cx_clone.clone(),
-                            )
-                            .await
-                            {
-                                Ok(result) => {
-                                    println!(
-                                        "Completed {} with template {} - score: {}",
-                                        exercise_name, template.name, result.score
-                                    );
-                                    exercise_results.push(result);
-                                }
-                                Err(err) => {
-                                    println!(
-                                        "Error running {} with template {}: {}",
-                                        exercise_name, template.name, err
-                                    );
-                                }
+                                // TODO: Persist errors / surface errors at the end.
+                                println!("Error loading {eval_name}: {err}");
+                                None
                            }
                        }
-
-                        // Save results for this exercise
-                        if !exercise_results.is_empty() {
-                            if let Err(err) =
-                                save_eval_results(&exercise_path, exercise_results.clone()).await
-                            {
-                                println!("Error saving results for {}: {}", exercise_name, err);
-                            } else {
-                                println!("Saved results for {}", exercise_name);
-                            }
-                        }
-
-                        exercise_results
                    }
                })
-                .collect();
+                .collect::<Vec<_>>();

-            println!(
-                "Running {} exercises with concurrency: {}",
-                exercise_tasks.len(),
-                args.concurrency
-            );
+            let loaded_evals = future::join_all(eval_load_futures)
+                .await
+                .into_iter()
+                .flatten()
+                .collect::<Vec<_>>();

-            // Run exercises concurrently, with each exercise running its templates sequentially
-            let all_results = stream::iter(exercise_tasks)
-                .buffer_unordered(args.concurrency)
-                .flat_map(stream::iter)
-                .collect::<Vec<_>>()
-                .await;
+            // The evals need to be loaded and grouped by URL before concurrently running, since
+            // evals that use the same remote URL will use the same working directory.
+            let mut evals_grouped_by_url: Vec<Vec<Eval>> = loaded_evals
+                .into_iter()
+                .map(|eval| (eval.eval_setup.url.clone(), eval))
+                .into_group_map()
+                .into_values()
+                .collect::<Vec<_>>();
+
+            // Sort groups in descending order, so that bigger groups start first.
+            evals_grouped_by_url.sort_by_key(|evals| cmp::Reverse(evals.len()));
+
+            let result_futures = evals_grouped_by_url
+                .into_iter()
+                .map(|evals| {
+                    let model = model.clone();
+                    let judge_model = judge_model.clone();
+                    let app_state = app_state.clone();
+                    let cx = cx.clone();
+
+                    async move {
+                        let mut results = Vec::new();
+                        for eval in evals {
+                            let name = eval.name.clone();
+                            println!("Starting eval named {}", name);
+                            let result = run_eval(
+                                eval,
+                                model.clone(),
+                                judge_model.clone(),
+                                app_state.clone(),
+                                cx.clone(),
+                            )
+                            .await;
+                            results.push((name, result));
+                        }
+                        results
+                    }
+                })
+                .collect::<Vec<_>>();
+
+            let results = future::join_all(result_futures)
+                .await
+                .into_iter()
+                .flatten()
+                .collect::<Vec<_>>();
+
+            // Process results in order of completion
+            for (eval_name, result) in results {
+                match result {
+                    Ok((eval_output, judge_output)) => {
+                        println!("Generated diff for {eval_name}:\n");
+                        println!("{}\n", eval_output.diff);
+                        println!("Last message for {eval_name}:\n");
+                        println!("{}\n", eval_output.last_message);
+                        println!("Elapsed time: {:?}", eval_output.elapsed_time);
+                        println!(
+                            "Assistant response count: {}",
+                            eval_output.assistant_response_count
+                        );
+                        println!("Tool use counts: {:?}", eval_output.tool_use_counts);
+                        println!("Judge output for {eval_name}: {judge_output}");
+                    }
+                    Err(err) => {
+                        // TODO: Persist errors / surface errors at the end.
+                        println!("Error running {eval_name}: {err}");
+                    }
+                }
+            }

-            println!("Completed {} evaluation runs", all_results.len());
            cx.update(|cx| cx.quit()).unwrap();
        })
        .detach();
@@ -256,3 +226,18 @@ fn main() {

    println!("Done running evals");
 }
+
+async fn run_eval(
+    eval: Eval,
+    model: Arc<dyn LanguageModel>,
+    judge_model: Arc<dyn LanguageModel>,
+    app_state: Arc<HeadlessAppState>,
+    cx: AsyncApp,
+) -> anyhow::Result<(EvalOutput, String)> {
+    let path = eval.path.clone();
+    let judge = Judge::load(&path, judge_model).await?;
+    let eval_output = cx.update(|cx| eval.run(app_state, model, cx))?.await?;
+    let judge_output = cx.update(|cx| judge.run(&eval_output, cx))?.await?;
+    eval_output.save_to_directory(&path, judge_output.to_string())?;
+    Ok((eval_output, judge_output))
+}
--- a/crates/assistant_eval/src/templates_eval.rs
+++ b/crates/assistant_eval/src/templates_eval.rs
@@ -1,210 +0,0 @@
-#[derive(Clone, Debug)]
-pub struct Template {
-    pub name: &'static str,
-    pub content: &'static str,
-}
-
-pub fn all_templates() -> Vec<Template> {
-    vec![
-        Template {
-            name: "ProjectCreation",
-            content: r#"
-# Project Creation Evaluation Template
-
-## Instructions
-
-Evaluate how well the AI assistant created a new implementation from scratch. Score it between 0.0 and 1.0 based on quality and fulfillment of requirements.
- 1.0 = Perfect implementation that creates all necessary files with correct functionality.
- 0.0 = Completely fails to create working files or meet requirements.
-
-Note: A git diff output is required. If no code changes are provided (i.e., no git diff output), the score must be 0.0.
-
-## Evaluation Criteria
-
-Please consider the following aspects in order of importance:
-
-1. **File Creation (25%)**
-   - Did the assistant create all necessary files?
-   - Are the files appropriately named and organized?
-   - Did the assistant create a complete solution without missing components?
-
-2. **Functional Correctness (40%)**
-   - Does the implementation fulfill all specified requirements?
-   - Does it handle edge cases properly?
-   - Is it free of logical errors and bugs?
-   - Do all components work together as expected?
-
-3. **Code Quality (20%)**
-   - Is the code well-structured, readable and well-documented?
-   - Does it follow language-specific best practices?
-   - Is there proper error handling?
-   - Are naming conventions clear and consistent?
-
-4. **Architecture Design (15%)**
-   - Is the code modular and extensible?
-   - Is there proper separation of concerns?
-   - Are appropriate design patterns used?
-   - Is the overall architecture appropriate for the requirements?
-
-## Input
-
-Requirements:
-<!-- ```requirements go here``` -->
-
-Reference Implementation:
-<!-- ```reference code goes here``` -->
-
-AI-Generated Implementation (git diff output):
-<!-- ```git diff goes here``` -->
-
-## Output Format
-
-THE ONLY OUTPUT SHOULD BE A SCORE BETWEEN 0.0 AND 1.0.
-
-EXAMPLE ONE:
-
-0.92
-
-EXAMPLE TWO:
-
-0.85
-
-EXAMPLE THREE:
-
-0.78
-"#,
-        },
-        Template {
-            name: "CodeModification",
-            content: r#"
-# Code Modification Evaluation Template
-
-## Instructions
-
-Evaluate how well the AI assistant modified existing code to meet requirements. Score between 0.0 and 1.0 based on quality and appropriateness of changes.
- 1.0 = Perfect modifications that correctly implement all requirements.
- 0.0 = Failed to make appropriate changes or introduced serious errors.
-
-## Evaluation Criteria
-
-Please consider the following aspects in order of importance:
-
-1. **Functional Correctness (50%)**
-   - Do the modifications correctly implement the requirements?
-   - Did the assistant modify the right files and code sections?
-   - Are the changes free of bugs and logical errors?
-   - Do the modifications maintain compatibility with existing code?
-
-2. **Modification Approach (25%)**
-   - Are the changes minimal and focused on what needs to be changed?
-   - Did the assistant avoid unnecessary modifications?
-   - Are the changes integrated seamlessly with the existing codebase?
-   - Did the assistant preserve the original code style and patterns?
-
-3. **Code Quality (15%)**
-   - Are the modifications well-structured and documented?
-   - Do they follow the same conventions as the original code?
-   - Is there proper error handling in the modified code?
-   - Are the changes readable and maintainable?
-
-4. **Solution Completeness (10%)**
-   - Do the modifications completely address all requirements?
-   - Are there any missing changes or overlooked requirements?
-   - Did the assistant consider all necessary edge cases?
-
-## Input
-
-Original:
-<!-- ```reference code goes here``` -->
-
-New (git diff output):
-<!-- ```git diff goes here``` -->
-
-## Output Format
-
-THE ONLY OUTPUT SHOULD BE A SCORE BETWEEN 0.0 AND 1.0.
-
-EXAMPLE ONE:
-
-0.92
-
-EXAMPLE TWO:
-
-0.85
-
-EXAMPLE THREE:
-
-0.78
-"#,
-        },
-        Template {
-            name: "ConversationalGuidance",
-            content: r#"
-# Conversational Guidance Evaluation Template
-
-## Instructions
-
-Evaluate the quality of the AI assistant's conversational guidance and score it between 0.0 and 1.0.
- 1.0 = Perfect guidance with ideal information gathering, clarification, and advice without writing code.
- 0.0 = Completely unhelpful, inappropriate guidance, or wrote code when it should not have.
-
-## Evaluation Criteria
-
-ABSOLUTE REQUIREMENT:
-   - The assistant should NOT generate complete code solutions in conversation mode.
-   - If the git diff shows the assistant wrote complete code, the score should be significantly reduced.
-
-1. **Information Gathering Effectiveness (30%)**
-   - Did the assistant ask relevant and precise questions?
-   - Did it efficiently narrow down the problem scope?
-   - Did it avoid unnecessary or redundant questions?
-   - Was questioning appropriately paced and contextual?
-
-2. **Conceptual Guidance (30%)**
-   - Did the assistant provide high-level approaches and strategies?
-   - Did it explain relevant concepts and algorithms?
-   - Did it offer planning advice without implementing the solution?
-   - Did it suggest a structured approach to solving the problem?
-
-3. **Educational Value (20%)**
-   - Did the assistant help the user understand the problem better?
-   - Did it provide explanations that would help the user learn?
-   - Did it guide without simply giving away answers?
-   - Did it encourage the user to think through parts of the problem?
-
-4. **Conversation Quality (20%)**
-   - Was the conversation logically structured and easy to follow?
-   - Did the assistant maintain appropriate context throughout?
-   - Was the interaction helpful without being condescending?
-   - Did the conversation reach a satisfactory conclusion with clear next steps?
-
-## Input
-
-Initial Query:
-<!-- ```query goes here``` -->
-
-Conversation Transcript:
-<!-- ```transcript goes here``` -->
-
-Git Diff:
-<!-- ```git diff goes here``` -->
-
-## Output Format
-
-THE ONLY OUTPUT SHOULD BE A SCORE BETWEEN 0.0 AND 1.0.
-
-EXAMPLE ONE:
-
-0.92
-
-EXAMPLE TWO:
-
-0.85
-
-EXAMPLE THREE:
-
-0.78
-"#,
-        },
-    ]
-}
--- a/crates/assistant_settings/Cargo.toml
+++ b/crates/assistant_settings/Cargo.toml
@@ -26,7 +26,6 @@ deepseek = { workspace = true, features = ["schemars"] }
 schemars.workspace = true
 serde.workspace = true
 settings.workspace = true
-workspace-hack.workspace = true

 [dev-dependencies]
 fs.workspace = true
--- a/crates/assistant_settings/src/agent_profile.rs
+++ b/crates/assistant_settings/src/agent_profile.rs
@@ -2,29 +2,6 @@ use std::sync::Arc;

 use gpui::SharedString;
 use indexmap::IndexMap;
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize, Deserialize, JsonSchema)]
-pub struct AgentProfileId(pub Arc<str>);
-
-impl AgentProfileId {
-    pub fn as_str(&self) -> &str {
-        &self.0
-    }
-}
-
-impl std::fmt::Display for AgentProfileId {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-impl Default for AgentProfileId {
-    fn default() -> Self {
-        Self("write".into())
-    }
-}

 /// A profile for the Zed Agent that controls its behavior.
 #[derive(Debug, Clone)]
@@ -32,7 +9,6 @@ pub struct AgentProfile {
    /// The name of the profile.
    pub name: SharedString,
    pub tools: IndexMap<Arc<str>, bool>,
-    pub enable_all_context_servers: bool,
    pub context_servers: IndexMap<Arc<str>, ContextServerPreset>,
 }

--- a/crates/assistant_settings/src/assistant_settings.rs
+++ b/crates/assistant_settings/src/assistant_settings.rs
@@ -77,14 +77,12 @@ pub struct AssistantSettings {
    pub default_width: Pixels,
    pub default_height: Pixels,
    pub default_model: LanguageModelSelection,
-    pub inline_assistant_model: Option<LanguageModelSelection>,
-    pub commit_message_model: Option<LanguageModelSelection>,
-    pub thread_summary_model: Option<LanguageModelSelection>,
+    pub editor_model: LanguageModelSelection,
    pub inline_alternatives: Vec<LanguageModelSelection>,
    pub using_outdated_settings_version: bool,
    pub enable_experimental_live_diffs: bool,
-    pub default_profile: AgentProfileId,
-    pub profiles: IndexMap<AgentProfileId, AgentProfile>,
+    pub default_profile: Arc<str>,
+    pub profiles: IndexMap<Arc<str>, AgentProfile>,
    pub always_allow_tool_actions: bool,
    pub notify_when_agent_waiting: NotifyWhenAgentWaiting,
 }
@@ -97,25 +95,13 @@ impl AssistantSettings {

        cx.is_staff() || self.enable_experimental_live_diffs
    }
-
-    pub fn set_inline_assistant_model(&mut self, provider: String, model: String) {
-        self.inline_assistant_model = Some(LanguageModelSelection { provider, model });
-    }
-
-    pub fn set_commit_message_model(&mut self, provider: String, model: String) {
-        self.commit_message_model = Some(LanguageModelSelection { provider, model });
-    }
-
-    pub fn set_thread_summary_model(&mut self, provider: String, model: String) {
-        self.thread_summary_model = Some(LanguageModelSelection { provider, model });
-    }
 }

 /// Assistant panel settings
 #[derive(Clone, Serialize, Deserialize, Debug)]
 #[serde(untagged)]
 pub enum AssistantSettingsContent {
-    Versioned(Box<VersionedAssistantSettingsContent>),
+    Versioned(VersionedAssistantSettingsContent),
    Legacy(LegacyAssistantSettingsContent),
 }

@@ -135,14 +121,14 @@ impl JsonSchema for AssistantSettingsContent {

 impl Default for AssistantSettingsContent {
    fn default() -> Self {
-        Self::Versioned(Box::new(VersionedAssistantSettingsContent::default()))
+        Self::Versioned(VersionedAssistantSettingsContent::default())
    }
 }

 impl AssistantSettingsContent {
    pub fn is_version_outdated(&self) -> bool {
        match self {
-            AssistantSettingsContent::Versioned(settings) => match **settings {
+            AssistantSettingsContent::Versioned(settings) => match settings {
                VersionedAssistantSettingsContent::V1(_) => true,
                VersionedAssistantSettingsContent::V2(_) => false,
            },
@@ -152,8 +138,8 @@ impl AssistantSettingsContent {

    fn upgrade(&self) -> AssistantSettingsContentV2 {
        match self {
-            AssistantSettingsContent::Versioned(settings) => match **settings {
-                VersionedAssistantSettingsContent::V1(ref settings) => AssistantSettingsContentV2 {
+            AssistantSettingsContent::Versioned(settings) => match settings {
+                VersionedAssistantSettingsContent::V1(settings) => AssistantSettingsContentV2 {
                    enabled: settings.enabled,
                    button: settings.button,
                    dock: settings.dock,
@@ -200,9 +186,7 @@ impl AssistantSettingsContent {
                                })
                            }
                        }),
-                    inline_assistant_model: None,
-                    commit_message_model: None,
-                    thread_summary_model: None,
+                    editor_model: None,
                    inline_alternatives: None,
                    enable_experimental_live_diffs: None,
                    default_profile: None,
@@ -210,7 +194,7 @@ impl AssistantSettingsContent {
                    always_allow_tool_actions: None,
                    notify_when_agent_waiting: None,
                },
-                VersionedAssistantSettingsContent::V2(ref settings) => settings.clone(),
+                VersionedAssistantSettingsContent::V2(settings) => settings.clone(),
            },
            AssistantSettingsContent::Legacy(settings) => AssistantSettingsContentV2 {
                enabled: None,
@@ -227,9 +211,7 @@ impl AssistantSettingsContent {
                        .id()
                        .to_string(),
                }),
-                inline_assistant_model: None,
-                commit_message_model: None,
-                thread_summary_model: None,
+                editor_model: None,
                inline_alternatives: None,
                enable_experimental_live_diffs: None,
                default_profile: None,
@@ -242,11 +224,11 @@ impl AssistantSettingsContent {

    pub fn set_dock(&mut self, dock: AssistantDockPosition) {
        match self {
-            AssistantSettingsContent::Versioned(settings) => match **settings {
-                VersionedAssistantSettingsContent::V1(ref mut settings) => {
+            AssistantSettingsContent::Versioned(settings) => match settings {
+                VersionedAssistantSettingsContent::V1(settings) => {
                    settings.dock = Some(dock);
                }
-                VersionedAssistantSettingsContent::V2(ref mut settings) => {
+                VersionedAssistantSettingsContent::V2(settings) => {
                    settings.dock = Some(dock);
                }
            },
@@ -261,79 +243,77 @@ impl AssistantSettingsContent {
        let provider = language_model.provider_id().0.to_string();

        match self {
-            AssistantSettingsContent::Versioned(settings) => match **settings {
-                VersionedAssistantSettingsContent::V1(ref mut settings) => {
-                    match provider.as_ref() {
-                        "zed.dev" => {
-                            log::warn!("attempted to set zed.dev model on outdated settings");
-                        }
-                        "anthropic" => {
-                            let api_url = match &settings.provider {
-                                Some(AssistantProviderContentV1::Anthropic { api_url, .. }) => {
-                                    api_url.clone()
-                                }
-                                _ => None,
-                            };
-                            settings.provider = Some(AssistantProviderContentV1::Anthropic {
-                                default_model: AnthropicModel::from_id(&model).ok(),
-                                api_url,
-                            });
-                        }
-                        "ollama" => {
-                            let api_url = match &settings.provider {
-                                Some(AssistantProviderContentV1::Ollama { api_url, .. }) => {
-                                    api_url.clone()
-                                }
-                                _ => None,
-                            };
-                            settings.provider = Some(AssistantProviderContentV1::Ollama {
-                                default_model: Some(ollama::Model::new(&model, None, None)),
-                                api_url,
-                            });
-                        }
-                        "lmstudio" => {
-                            let api_url = match &settings.provider {
-                                Some(AssistantProviderContentV1::LmStudio { api_url, .. }) => {
-                                    api_url.clone()
-                                }
-                                _ => None,
-                            };
-                            settings.provider = Some(AssistantProviderContentV1::LmStudio {
-                                default_model: Some(lmstudio::Model::new(&model, None, None)),
-                                api_url,
-                            });
-                        }
-                        "openai" => {
-                            let (api_url, available_models) = match &settings.provider {
-                                Some(AssistantProviderContentV1::OpenAi {
-                                    api_url,
-                                    available_models,
-                                    ..
-                                }) => (api_url.clone(), available_models.clone()),
-                                _ => (None, None),
-                            };
-                            settings.provider = Some(AssistantProviderContentV1::OpenAi {
-                                default_model: OpenAiModel::from_id(&model).ok(),
+            AssistantSettingsContent::Versioned(settings) => match settings {
+                VersionedAssistantSettingsContent::V1(settings) => match provider.as_ref() {
+                    "zed.dev" => {
+                        log::warn!("attempted to set zed.dev model on outdated settings");
+                    }
+                    "anthropic" => {
+                        let api_url = match &settings.provider {
+                            Some(AssistantProviderContentV1::Anthropic { api_url, .. }) => {
+                                api_url.clone()
+                            }
+                            _ => None,
+                        };
+                        settings.provider = Some(AssistantProviderContentV1::Anthropic {
+                            default_model: AnthropicModel::from_id(&model).ok(),
+                            api_url,
+                        });
+                    }
+                    "ollama" => {
+                        let api_url = match &settings.provider {
+                            Some(AssistantProviderContentV1::Ollama { api_url, .. }) => {
+                                api_url.clone()
+                            }
+                            _ => None,
+                        };
+                        settings.provider = Some(AssistantProviderContentV1::Ollama {
+                            default_model: Some(ollama::Model::new(&model, None, None)),
+                            api_url,
+                        });
+                    }
+                    "lmstudio" => {
+                        let api_url = match &settings.provider {
+                            Some(AssistantProviderContentV1::LmStudio { api_url, .. }) => {
+                                api_url.clone()
+                            }
+                            _ => None,
+                        };
+                        settings.provider = Some(AssistantProviderContentV1::LmStudio {
+                            default_model: Some(lmstudio::Model::new(&model, None, None)),
+                            api_url,
+                        });
+                    }
+                    "openai" => {
+                        let (api_url, available_models) = match &settings.provider {
+                            Some(AssistantProviderContentV1::OpenAi {
                                api_url,
                                available_models,
-                            });
-                        }
-                        "deepseek" => {
-                            let api_url = match &settings.provider {
-                                Some(AssistantProviderContentV1::DeepSeek { api_url, .. }) => {
-                                    api_url.clone()
-                                }
-                                _ => None,
-                            };
-                            settings.provider = Some(AssistantProviderContentV1::DeepSeek {
-                                default_model: DeepseekModel::from_id(&model).ok(),
-                                api_url,
-                            });
-                        }
-                        _ => {}
+                                ..
+                            }) => (api_url.clone(), available_models.clone()),
+                            _ => (None, None),
+                        };
+                        settings.provider = Some(AssistantProviderContentV1::OpenAi {
+                            default_model: OpenAiModel::from_id(&model).ok(),
+                            api_url,
+                            available_models,
+                        });
                    }
-                }
-                VersionedAssistantSettingsContent::V2(ref mut settings) => {
+                    "deepseek" => {
+                        let api_url = match &settings.provider {
+                            Some(AssistantProviderContentV1::DeepSeek { api_url, .. }) => {
+                                api_url.clone()
+                            }
+                            _ => None,
+                        };
+                        settings.provider = Some(AssistantProviderContentV1::DeepSeek {
+                            default_model: DeepseekModel::from_id(&model).ok(),
+                            api_url,
+                        });
+                    }
+                    _ => {}
+                },
+                VersionedAssistantSettingsContent::V2(settings) => {
                    settings.default_model = Some(LanguageModelSelection { provider, model });
                }
            },
@@ -345,87 +325,48 @@ impl AssistantSettingsContent {
        }
    }

-    pub fn set_inline_assistant_model(&mut self, provider: String, model: String) {
-        if let AssistantSettingsContent::Versioned(boxed) = self {
-            if let VersionedAssistantSettingsContent::V2(ref mut settings) = **boxed {
-                settings.inline_assistant_model = Some(LanguageModelSelection { provider, model });
-            }
-        }
-    }
-
-    pub fn set_commit_message_model(&mut self, provider: String, model: String) {
-        if let AssistantSettingsContent::Versioned(boxed) = self {
-            if let VersionedAssistantSettingsContent::V2(ref mut settings) = **boxed {
-                settings.commit_message_model = Some(LanguageModelSelection { provider, model });
-            }
-        }
-    }
-
-    pub fn set_thread_summary_model(&mut self, provider: String, model: String) {
-        if let AssistantSettingsContent::Versioned(boxed) = self {
-            if let VersionedAssistantSettingsContent::V2(ref mut settings) = **boxed {
-                settings.thread_summary_model = Some(LanguageModelSelection { provider, model });
-            }
-        }
-    }
-
-    pub fn set_always_allow_tool_actions(&mut self, allow: bool) {
-        let AssistantSettingsContent::Versioned(boxed) = self else {
+    pub fn set_profile(&mut self, profile_id: Arc<str>) {
+        let AssistantSettingsContent::Versioned(VersionedAssistantSettingsContent::V2(settings)) =
+            self
+        else {
            return;
        };

-        if let VersionedAssistantSettingsContent::V2(ref mut settings) = **boxed {
-            settings.always_allow_tool_actions = Some(allow);
-        }
+        settings.default_profile = Some(profile_id);
    }

-    pub fn set_profile(&mut self, profile_id: AgentProfileId) {
-        let AssistantSettingsContent::Versioned(boxed) = self else {
-            return;
-        };
-
-        if let VersionedAssistantSettingsContent::V2(ref mut settings) = **boxed {
-            settings.default_profile = Some(profile_id);
-        }
-    }
-
-    pub fn create_profile(
-        &mut self,
-        profile_id: AgentProfileId,
-        profile: AgentProfile,
-    ) -> Result<()> {
-        let AssistantSettingsContent::Versioned(boxed) = self else {
+    pub fn create_profile(&mut self, profile_id: Arc<str>, profile: AgentProfile) -> Result<()> {
+        let AssistantSettingsContent::Versioned(VersionedAssistantSettingsContent::V2(settings)) =
+            self
+        else {
            return Ok(());
        };

-        if let VersionedAssistantSettingsContent::V2(ref mut settings) = **boxed {
-            let profiles = settings.profiles.get_or_insert_default();
-            if profiles.contains_key(&profile_id) {
-                bail!("profile with ID '{profile_id}' already exists");
-            }
-
-            profiles.insert(
-                profile_id,
-                AgentProfileContent {
-                    name: profile.name.into(),
-                    tools: profile.tools,
-                    enable_all_context_servers: Some(profile.enable_all_context_servers),
-                    context_servers: profile
-                        .context_servers
-                        .into_iter()
-                        .map(|(server_id, preset)| {
-                            (
-                                server_id,
-                                ContextServerPresetContent {
-                                    tools: preset.tools,
-                                },
-                            )
-                        })
-                        .collect(),
-                },
-            );
+        let profiles = settings.profiles.get_or_insert_default();
+        if profiles.contains_key(&profile_id) {
+            bail!("profile with ID '{profile_id}' already exists");
        }

+        profiles.insert(
+            profile_id,
+            AgentProfileContent {
+                name: profile.name.into(),
+                tools: profile.tools,
+                context_servers: profile
+                    .context_servers
+                    .into_iter()
+                    .map(|(server_id, preset)| {
+                        (
+                            server_id,
+                            ContextServerPresetContent {
+                                tools: preset.tools,
+                            },
+                        )
+                    })
+                    .collect(),
+            },
+        );
+
        Ok(())
    }
 }
@@ -448,9 +389,7 @@ impl Default for VersionedAssistantSettingsContent {
            default_width: None,
            default_height: None,
            default_model: None,
-            inline_assistant_model: None,
-            commit_message_model: None,
-            thread_summary_model: None,
+            editor_model: None,
            inline_alternatives: None,
            enable_experimental_live_diffs: None,
            default_profile: None,
@@ -483,26 +422,20 @@ pub struct AssistantSettingsContentV2 {
    ///
    /// Default: 320
    default_height: Option<f32>,
-    /// The default model to use when creating new chats and for other features when a specific model is not specified.
+    /// The default model to use when creating new chats.
    default_model: Option<LanguageModelSelection>,
-    /// Model to use for the inline assistant. Defaults to default_model when not specified.
-    inline_assistant_model: Option<LanguageModelSelection>,
-    /// Model to use for generating git commit messages. Defaults to default_model when not specified.
-    commit_message_model: Option<LanguageModelSelection>,
-    /// Model to use for generating thread summaries. Defaults to default_model when not specified.
-    thread_summary_model: Option<LanguageModelSelection>,
+    /// The model to use when applying edits from the assistant.
+    editor_model: Option<LanguageModelSelection>,
    /// Additional models with which to generate alternatives when performing inline assists.
    inline_alternatives: Option<Vec<LanguageModelSelection>>,
    /// Enable experimental live diffs in the assistant panel.
    ///
    /// Default: false
    enable_experimental_live_diffs: Option<bool>,
-    /// The default profile to use in the Agent.
-    ///
-    /// Default: write
-    default_profile: Option<AgentProfileId>,
-    /// The available agent profiles.
-    pub profiles: Option<IndexMap<AgentProfileId, AgentProfileContent>>,
+    #[schemars(skip)]
+    default_profile: Option<Arc<str>>,
+    #[schemars(skip)]
+    pub profiles: Option<IndexMap<Arc<str>, AgentProfileContent>>,
    /// Whenever a tool action would normally wait for your confirmation
    /// that you allow it, always choose to allow it.
    ///
@@ -551,10 +484,7 @@ impl Default for LanguageModelSelection {
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize, JsonSchema)]
 pub struct AgentProfileContent {
    pub name: Arc<str>,
-    #[serde(default)]
    pub tools: IndexMap<Arc<str>, bool>,
-    /// Whether all context servers are enabled by default.
-    pub enable_all_context_servers: Option<bool>,
    #[serde(default)]
    pub context_servers: IndexMap<Arc<str>, ContextServerPresetContent>,
 }
@@ -652,15 +582,7 @@ impl Settings for AssistantSettings {
                value.default_height.map(Into::into),
            );
            merge(&mut settings.default_model, value.default_model);
-            settings.inline_assistant_model = value
-                .inline_assistant_model
-                .or(settings.inline_assistant_model.take());
-            settings.commit_message_model = value
-                .commit_message_model
-                .or(settings.commit_message_model.take());
-            settings.thread_summary_model = value
-                .thread_summary_model
-                .or(settings.thread_summary_model.take());
+            merge(&mut settings.editor_model, value.editor_model);
            merge(&mut settings.inline_alternatives, value.inline_alternatives);
            merge(
                &mut settings.enable_experimental_live_diffs,
@@ -685,9 +607,6 @@ impl Settings for AssistantSettings {
                            AgentProfile {
                                name: profile.name.into(),
                                tools: profile.tools,
-                                enable_all_context_servers: profile
-                                    .enable_all_context_servers
-                                    .unwrap_or_default(),
                                context_servers: profile
                                    .context_servers
                                    .into_iter()
@@ -751,15 +670,16 @@ mod tests {
            settings::SettingsStore::global(cx).update_settings_file::<AssistantSettings>(
                fs.clone(),
                |settings, _| {
-                    *settings = AssistantSettingsContent::Versioned(Box::new(
+                    *settings = AssistantSettingsContent::Versioned(
                        VersionedAssistantSettingsContent::V2(AssistantSettingsContentV2 {
                            default_model: Some(LanguageModelSelection {
                                provider: "test-provider".into(),
                                model: "gpt-99".into(),
                            }),
-                            inline_assistant_model: None,
-                            commit_message_model: None,
-                            thread_summary_model: None,
+                            editor_model: Some(LanguageModelSelection {
+                                provider: "test-provider".into(),
+                                model: "gpt-99".into(),
+                            }),
                            inline_alternatives: None,
                            enabled: None,
                            button: None,
@@ -772,7 +692,7 @@ mod tests {
                            always_allow_tool_actions: None,
                            notify_when_agent_waiting: None,
                        }),
-                    ))
+                    )
                },
            );
        });
--- a/crates/assistant_slash_command/Cargo.toml
+++ b/crates/assistant_slash_command/Cargo.toml
@@ -26,7 +26,6 @@ serde.workspace = true
 serde_json.workspace = true
 ui.workspace = true
 workspace.workspace = true
-workspace-hack.workspace = true

 [dev-dependencies]
 gpui = { workspace = true, features = ["test-support"] }
--- a/crates/assistant_slash_commands/Cargo.toml
+++ b/crates/assistant_slash_commands/Cargo.toml
@@ -42,7 +42,6 @@ ui.workspace = true
 util.workspace = true
 workspace.workspace = true
 worktree.workspace = true
-workspace-hack.workspace = true

 [dev-dependencies]
 env_logger.workspace = true
--- a/crates/assistant_tool/Cargo.toml
+++ b/crates/assistant_tool/Cargo.toml
@@ -13,11 +13,11 @@ path = "src/assistant_tool.rs"

 [dependencies]
 anyhow.workspace = true
+async-watch.workspace = true
 buffer_diff.workspace = true
 clock.workspace = true
 collections.workspace = true
 derive_more.workspace = true
-futures.workspace = true
 gpui.workspace = true
 icons.workspace = true
 language.workspace = true
@@ -27,22 +27,15 @@ project.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 text.workspace = true
-util.workspace = true
-workspace-hack.workspace = true

 [dev-dependencies]
 buffer_diff = { workspace = true, features = ["test-support"] }
 collections = { workspace = true, features = ["test-support"] }
 clock = { workspace = true, features = ["test-support"] }
-ctor.workspace = true
-env_logger.workspace = true
 gpui = { workspace = true, features = ["test-support"] }
 language = { workspace = true, features = ["test-support"] }
 language_model = { workspace = true, features = ["test-support"] }
-log.workspace = true
-pretty_assertions.workspace = true
 project = { workspace = true, features = ["test-support"] }
-rand.workspace = true
 settings = { workspace = true, features = ["test-support"] }
 text = { workspace = true, features = ["test-support"] }
 util = { workspace = true, features = ["test-support"] }
--- a/crates/assistant_tool/src/action_log.rs
+++ b/crates/assistant_tool/src/action_log.rs
--- a/crates/assistant_tool/src/tool_working_set.rs
+++ b/crates/assistant_tool/src/tool_working_set.rs
@@ -19,7 +19,6 @@ pub struct ToolWorkingSet {
 struct WorkingSetState {
    context_server_tools_by_id: HashMap<ToolId, Arc<dyn Tool>>,
    context_server_tools_by_name: HashMap<String, Arc<dyn Tool>>,
-    enabled_sources: HashSet<ToolSource>,
    enabled_tools_by_source: HashMap<ToolSource, HashSet<Arc<str>>>,
    next_tool_id: ToolId,
 }
@@ -169,22 +168,21 @@ impl WorkingSetState {
    }

    fn enable_source(&mut self, source: ToolSource, cx: &App) {
-        self.enabled_sources.insert(source.clone());
-
        let tools_by_source = self.tools_by_source(cx);
-        if let Some(tools) = tools_by_source.get(&source) {
-            self.enabled_tools_by_source.insert(
-                source,
-                tools
-                    .into_iter()
-                    .map(|tool| tool.name().into())
-                    .collect::<HashSet<_>>(),
-            );
-        }
+        let Some(tools) = tools_by_source.get(&source) else {
+            return;
+        };
+
+        self.enabled_tools_by_source.insert(
+            source,
+            tools
+                .into_iter()
+                .map(|tool| tool.name().into())
+                .collect::<HashSet<_>>(),
+        );
    }

    fn disable_source(&mut self, source: &ToolSource) {
-        self.enabled_sources.remove(source);
        self.enabled_tools_by_source.remove(source);
    }

--- a/crates/assistant_tools/Cargo.toml
+++ b/crates/assistant_tools/Cargo.toml
@@ -14,8 +14,10 @@ path = "src/assistant_tools.rs"
 [dependencies]
 anyhow.workspace = true
 assistant_tool.workspace = true
+clock.workspace = true
 chrono.workspace = true
 collections.workspace = true
+feature_flags.workspace = true
 futures.workspace = true
 gpui.workspace = true
 html_to_markdown.workspace = true
@@ -23,19 +25,24 @@ http_client.workspace = true
 itertools.workspace = true
 language.workspace = true
 language_model.workspace = true
+log.workspace = true
 lsp.workspace = true
 project.workspace = true
 regex.workspace = true
+release_channel.workspace = true
 schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+settings.workspace = true
+theme.workspace = true
 ui.workspace = true
 util.workspace = true
+workspace.workspace = true
 worktree.workspace = true
 open = { workspace = true }
-workspace-hack.workspace = true

 [dev-dependencies]
+clock = { workspace = true, features = ["test-support"] }
 collections = { workspace = true, features = ["test-support"] }
 gpui = { workspace = true, features = ["test-support"] }
 language = { workspace = true, features = ["test-support"] }
--- a/crates/assistant_tools/src/assistant_tools.rs
+++ b/crates/assistant_tools/src/assistant_tools.rs
@@ -7,6 +7,7 @@ mod create_directory_tool;
 mod create_file_tool;
 mod delete_path_tool;
 mod diagnostics_tool;
+mod edit_files_tool;
 mod fetch_tool;
 mod find_replace_file_tool;
 mod list_directory_tool;
@@ -36,6 +37,7 @@ use crate::create_directory_tool::CreateDirectoryTool;
 use crate::create_file_tool::CreateFileTool;
 use crate::delete_path_tool::DeletePathTool;
 use crate::diagnostics_tool::DiagnosticsTool;
+use crate::edit_files_tool::EditFilesTool;
 use crate::fetch_tool::FetchTool;
 use crate::find_replace_file_tool::FindReplaceFileTool;
 use crate::list_directory_tool::ListDirectoryTool;
@@ -49,6 +51,7 @@ use crate::thinking_tool::ThinkingTool;

 pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut App) {
    assistant_tool::init(cx);
+    crate::edit_files_tool::log::init(cx);

    let registry = ToolRegistry::global(cx);
    registry.register_tool(BashTool);
@@ -61,6 +64,7 @@ pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut App) {
    registry.register_tool(SymbolInfoTool);
    registry.register_tool(MovePathTool);
    registry.register_tool(DiagnosticsTool);
+    registry.register_tool(EditFilesTool);
    registry.register_tool(ListDirectoryTool);
    registry.register_tool(NowTool);
    registry.register_tool(OpenTool);
--- a/crates/assistant_tools/src/bash_tool.rs
+++ b/crates/assistant_tools/src/bash_tool.rs
@@ -46,21 +46,10 @@ impl Tool for BashTool {
    fn ui_text(&self, input: &serde_json::Value) -> String {
        match serde_json::from_value::<BashToolInput>(input.clone()) {
            Ok(input) => {
-                let mut lines = input.command.lines();
-                let first_line = lines.next().unwrap_or_default();
-                let remaining_line_count = lines.count();
-                match remaining_line_count {
-                    0 => MarkdownString::inline_code(&first_line).0,
-                    1 => {
-                        MarkdownString::inline_code(&format!(
-                            "{} - {} more line",
-                            first_line, remaining_line_count
-                        ))
-                        .0
-                    }
-                    n => {
-                        MarkdownString::inline_code(&format!("{} - {} more lines", first_line, n)).0
-                    }
+                if input.command.contains('\n') {
+                    MarkdownString::code_block("bash", &input.command).0
+                } else {
+                    MarkdownString::inline_code(&input.command).0
                }
            }
            Err(_) => "Run bash command".to_string(),
--- a/crates/assistant_tools/src/batch_tool.rs
+++ b/crates/assistant_tools/src/batch_tool.rs
@@ -31,19 +31,19 @@ pub struct BatchToolInput {
    /// {
    ///   "invocations": [
    ///     {
-    ///       "name": "read_file",
+    ///       "name": "read-file",
    ///       "input": {
    ///         "path": "src/main.rs"
    ///       }
    ///     },
    ///     {
-    ///       "name": "list_directory",
+    ///       "name": "list-directory",
    ///       "input": {
    ///         "path": "src/lib"
    ///       }
    ///     },
    ///     {
-    ///       "name": "regex_search",
+    ///       "name": "regex-search",
    ///       "input": {
    ///         "regex": "fn run\\("
    ///       }
@@ -61,7 +61,7 @@ pub struct BatchToolInput {
    /// {
    ///   "invocations": [
    ///     {
-    ///       "name": "find_replace_file",
+    ///       "name": "find-replace-file",
    ///       "input": {
    ///         "path": "src/config.rs",
    ///         "display_description": "Update default timeout value",
@@ -70,7 +70,7 @@ pub struct BatchToolInput {
    ///       }
    ///     },
    ///     {
-    ///       "name": "find_replace_file",
+    ///       "name": "find-replace-file",
    ///       "input": {
    ///         "path": "src/config.rs",
    ///         "display_description": "Update API endpoint URL",
@@ -91,13 +91,13 @@ pub struct BatchToolInput {
    /// {
    ///   "invocations": [
    ///     {
-    ///       "name": "regex_search",
+    ///       "name": "regex-search",
    ///       "input": {
    ///         "regex": "impl Database"
    ///       }
    ///     },
    ///     {
-    ///       "name": "path_search",
+    ///       "name": "path-search",
    ///       "input": {
    ///         "glob": "**/*test*.rs"
    ///       }
@@ -115,7 +115,7 @@ pub struct BatchToolInput {
    /// {
    ///   "invocations": [
    ///     {
-    ///       "name": "find_replace_file",
+    ///       "name": "find-replace-file",
    ///       "input": {
    ///         "path": "src/models/user.rs",
    ///         "display_description": "Add email field to User struct",
@@ -124,7 +124,7 @@ pub struct BatchToolInput {
    ///       }
    ///     },
    ///     {
-    ///       "name": "find_replace_file",
+    ///       "name": "find-replace-file",
    ///       "input": {
    ///         "path": "src/db/queries.rs",
    ///         "display_description": "Update user insertion query",
@@ -148,7 +148,7 @@ pub struct BatchTool;

 impl Tool for BatchTool {
    fn name(&self) -> String {
-        "batch_tool".into()
+        "batch-tool".into()
    }

    fn needs_confirmation(&self) -> bool {
--- a/crates/assistant_tools/src/code_symbols_tool.rs
+++ b/crates/assistant_tools/src/code_symbols_tool.rs
@@ -79,7 +79,7 @@ pub struct CodeSymbolsTool;

 impl Tool for CodeSymbolsTool {
    fn name(&self) -> String {
-        "code_symbols".into()
+        "code-symbols".into()
    }

    fn needs_confirmation(&self) -> bool {
@@ -156,7 +156,7 @@ impl Tool for CodeSymbolsTool {
    }
 }

-pub async fn file_outline(
+async fn file_outline(
    project: Entity<Project>,
    path: String,
    action_log: Entity<ActionLog>,
--- a/crates/assistant_tools/src/copy_path_tool.rs
+++ b/crates/assistant_tools/src/copy_path_tool.rs
@@ -40,7 +40,7 @@ pub struct CopyPathTool;

 impl Tool for CopyPathTool {
    fn name(&self) -> String {
-        "copy_path".into()
+        "copy-path".into()
    }

    fn needs_confirmation(&self) -> bool {
--- a/crates/assistant_tools/src/create_directory_tool.rs
+++ b/crates/assistant_tools/src/create_directory_tool.rs
@@ -30,7 +30,7 @@ pub struct CreateDirectoryTool;

 impl Tool for CreateDirectoryTool {
    fn name(&self) -> String {
-        "create_directory".into()
+        "create-directory".into()
    }

    fn needs_confirmation(&self) -> bool {
--- a/crates/assistant_tools/src/create_file_tool.rs
+++ b/crates/assistant_tools/src/create_file_tool.rs
@@ -37,11 +37,11 @@ pub struct CreateFileTool;

 impl Tool for CreateFileTool {
    fn name(&self) -> String {
-        "create_file".into()
+        "create-file".into()
    }

    fn needs_confirmation(&self) -> bool {
-        false
+        true
    }

    fn description(&self) -> String {
@@ -92,11 +92,10 @@ impl Tool for CreateFileTool {
                })?
                .await
                .map_err(|err| anyhow!("Unable to open buffer for {destination_path}: {err}"))?;
-            cx.update(|cx| {
-                buffer.update(cx, |buffer, cx| buffer.set_text(contents, cx));
-                action_log.update(cx, |action_log, cx| {
-                    action_log.will_create_buffer(buffer.clone(), cx)
-                });
+            let edit_id = buffer.update(cx, |buffer, cx| buffer.set_text(contents, cx))?;
+
+            action_log.update(cx, |action_log, cx| {
+                action_log.will_create_buffer(buffer.clone(), edit_id, cx)
            })?;

            project
--- a/crates/assistant_tools/src/delete_path_tool.rs
+++ b/crates/assistant_tools/src/delete_path_tool.rs
@@ -30,7 +30,7 @@ pub struct DeletePathTool;

 impl Tool for DeletePathTool {
    fn name(&self) -> String {
-        "delete_path".into()
+        "delete-path".into()
    }

    fn needs_confirmation(&self) -> bool {
--- a/crates/assistant_tools/src/edit_files_tool.rs
+++ b/crates/assistant_tools/src/edit_files_tool.rs
@@ -0,0 +1,562 @@
+mod edit_action;
+pub mod log;
+
+use crate::replace::{replace_exact, replace_with_flexible_indent};
+use crate::schema::json_schema_for;
+use anyhow::{Context, Result, anyhow};
+use assistant_tool::{ActionLog, Tool};
+use collections::HashSet;
+use edit_action::{EditAction, EditActionParser, edit_model_prompt};
+use futures::{SinkExt, StreamExt, channel::mpsc};
+use gpui::{App, AppContext, AsyncApp, Entity, Task};
+use language_model::LanguageModelToolSchemaFormat;
+use language_model::{
+    LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, MessageContent, Role,
+};
+use log::{EditToolLog, EditToolRequestId};
+use project::Project;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::fmt::Write;
+use std::sync::Arc;
+use ui::IconName;
+use util::ResultExt;
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct EditFilesToolInput {
+    /// High-level edit instructions. These will be interpreted by a smaller
+    /// model, so explain the changes you want that model to make and which
+    /// file paths need changing. The description should be concise and clear.
+    ///
+    /// WARNING: When specifying which file paths need changing, you MUST
+    /// start each path with one of the project's root directories.
+    ///
+    /// WARNING: NEVER include code blocks or snippets in edit instructions.
+    /// Only provide natural language descriptions of the changes needed! The tool will
+    /// reject any instructions that contain code blocks or snippets.
+    ///
+    /// The following examples assume we have two root directories in the project:
+    /// - root-1
+    /// - root-2
+    ///
+    /// <example>
+    /// If you want to introduce a new quit function to kill the process, your
+    /// instructions should be: "Add a new `quit` function to
+    /// `root-1/src/main.rs` to kill the process".
+    ///
+    /// Notice how the file path starts with root-1. Without that, the path
+    /// would be ambiguous and the call would fail!
+    /// </example>
+    ///
+    /// <example>
+    /// If you want to change documentation to always start with a capital
+    /// letter, your instructions should be: "In `root-2/db.js`,
+    /// `root-2/inMemory.js` and `root-2/sql.js`, change all the documentation
+    /// to start with a capital letter".
+    ///
+    /// Notice how we never specify code snippets in the instructions!
+    /// </example>
+    pub edit_instructions: String,
+
+    /// A user-friendly description of what changes are being made.
+    /// This will be shown to the user in the UI to describe the edit operation. The screen real estate for this UI will be extremely
+    /// constrained, so make the description extremely terse.
+    ///
+    /// <example>
+    /// For fixing a broken authentication system:
+    /// "Fix auth bug in login flow"
+    /// </example>
+    ///
+    /// <example>
+    /// For adding unit tests to a module:
+    /// "Add tests for user profile logic"
+    /// </example>
+    pub display_description: String,
+}
+
+pub struct EditFilesTool;
+
+impl Tool for EditFilesTool {
+    fn name(&self) -> String {
+        "edit-files".into()
+    }
+
+    fn needs_confirmation(&self) -> bool {
+        true
+    }
+
+    fn description(&self) -> String {
+        include_str!("./edit_files_tool/description.md").into()
+    }
+
+    fn icon(&self) -> IconName {
+        IconName::Pencil
+    }
+
+    fn input_schema(&self, format: LanguageModelToolSchemaFormat) -> serde_json::Value {
+        json_schema_for::<EditFilesToolInput>(format)
+    }
+
+    fn ui_text(&self, input: &serde_json::Value) -> String {
+        match serde_json::from_value::<EditFilesToolInput>(input.clone()) {
+            Ok(input) => input.display_description,
+            Err(_) => "Edit files".to_string(),
+        }
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: serde_json::Value,
+        messages: &[LanguageModelRequestMessage],
+        project: Entity<Project>,
+        action_log: Entity<ActionLog>,
+        cx: &mut App,
+    ) -> Task<Result<String>> {
+        let input = match serde_json::from_value::<EditFilesToolInput>(input) {
+            Ok(input) => input,
+            Err(err) => return Task::ready(Err(anyhow!(err))),
+        };
+
+        match EditToolLog::try_global(cx) {
+            Some(log) => {
+                let req_id = log.update(cx, |log, cx| {
+                    log.new_request(input.edit_instructions.clone(), cx)
+                });
+
+                let task = EditToolRequest::new(
+                    input,
+                    messages,
+                    project,
+                    action_log,
+                    Some((log.clone(), req_id)),
+                    cx,
+                );
+
+                cx.spawn(async move |cx| {
+                    let result = task.await;
+
+                    let str_result = match &result {
+                        Ok(out) => Ok(out.clone()),
+                        Err(err) => Err(err.to_string()),
+                    };
+
+                    log.update(cx, |log, cx| log.set_tool_output(req_id, str_result, cx))
+                        .log_err();
+
+                    result
+                })
+            }
+
+            None => EditToolRequest::new(input, messages, project, action_log, None, cx),
+        }
+    }
+}
+
+struct EditToolRequest {
+    parser: EditActionParser,
+    editor_response: EditorResponse,
+    project: Entity<Project>,
+    action_log: Entity<ActionLog>,
+    tool_log: Option<(Entity<EditToolLog>, EditToolRequestId)>,
+}
+
+enum EditorResponse {
+    /// The editor model hasn't produced any actions yet.
+    /// If we don't have any by the end, we'll return its message to the architect model.
+    Message(String),
+    /// The editor model produced at least one action.
+    Actions {
+        applied: Vec<AppliedAction>,
+        search_errors: Vec<SearchError>,
+    },
+}
+
+struct AppliedAction {
+    source: String,
+    buffer: Entity<language::Buffer>,
+    edit_ids: Vec<clock::Lamport>,
+}
+
+#[derive(Debug)]
+enum DiffResult {
+    Diff(language::Diff),
+    SearchError(SearchError),
+}
+
+#[derive(Debug)]
+enum SearchError {
+    NoMatch {
+        file_path: String,
+        search: String,
+    },
+    EmptyBuffer {
+        file_path: String,
+        search: String,
+        exists: bool,
+    },
+}
+
+impl EditToolRequest {
+    fn new(
+        input: EditFilesToolInput,
+        messages: &[LanguageModelRequestMessage],
+        project: Entity<Project>,
+        action_log: Entity<ActionLog>,
+        tool_log: Option<(Entity<EditToolLog>, EditToolRequestId)>,
+        cx: &mut App,
+    ) -> Task<Result<String>> {
+        let model_registry = LanguageModelRegistry::read_global(cx);
+        let Some(model) = model_registry.editor_model() else {
+            return Task::ready(Err(anyhow!("No editor model configured")));
+        };
+
+        let mut messages = messages.to_vec();
+        // Remove the last tool use (this run) to prevent an invalid request
+        'outer: for message in messages.iter_mut().rev() {
+            for (index, content) in message.content.iter().enumerate().rev() {
+                match content {
+                    MessageContent::ToolUse(_) => {
+                        message.content.remove(index);
+                        break 'outer;
+                    }
+                    MessageContent::ToolResult(_) => {
+                        // If we find any tool results before a tool use, the request is already valid
+                        break 'outer;
+                    }
+                    MessageContent::Text(_) | MessageContent::Image(_) => {}
+                }
+            }
+        }
+
+        messages.push(LanguageModelRequestMessage {
+            role: Role::User,
+            content: vec![edit_model_prompt().into(), input.edit_instructions.into()],
+            cache: false,
+        });
+
+        cx.spawn(async move |cx| {
+            let llm_request = LanguageModelRequest {
+                messages,
+                tools: vec![],
+                stop: vec![],
+                temperature: Some(0.0),
+            };
+
+            let (mut tx, mut rx) = mpsc::channel::<String>(32);
+            let stream = model.stream_completion_text(llm_request, &cx);
+            let reader_task = cx.background_spawn(async move {
+                let mut chunks = stream.await?;
+
+                while let Some(chunk) = chunks.stream.next().await {
+                    if let Some(chunk) = chunk.log_err() {
+                        // we don't process here because the API fails
+                        // if we take too long between reads
+                        tx.send(chunk).await?
+                    }
+                }
+                tx.close().await?;
+                anyhow::Ok(())
+            });
+
+            let mut request = Self {
+                parser: EditActionParser::new(),
+                editor_response: EditorResponse::Message(String::with_capacity(256)),
+                action_log,
+                project,
+                tool_log,
+            };
+
+            while let Some(chunk) = rx.next().await {
+                request.process_response_chunk(&chunk, cx).await?;
+            }
+
+            reader_task.await?;
+
+            request.finalize(cx).await
+        })
+    }
+
+    async fn process_response_chunk(&mut self, chunk: &str, cx: &mut AsyncApp) -> Result<()> {
+        let new_actions = self.parser.parse_chunk(chunk);
+
+        if let EditorResponse::Message(ref mut message) = self.editor_response {
+            if new_actions.is_empty() {
+                message.push_str(chunk);
+            }
+        }
+
+        if let Some((ref log, req_id)) = self.tool_log {
+            log.update(cx, |log, cx| {
+                log.push_editor_response_chunk(req_id, chunk, &new_actions, cx)
+            })
+            .log_err();
+        }
+
+        for action in new_actions {
+            self.apply_action(action, cx).await?;
+        }
+
+        Ok(())
+    }
+
+    async fn apply_action(
+        &mut self,
+        (action, source): (EditAction, String),
+        cx: &mut AsyncApp,
+    ) -> Result<()> {
+        let project_path = self.project.read_with(cx, |project, cx| {
+            project
+                .find_project_path(action.file_path(), cx)
+                .context("Path not found in project")
+        })??;
+
+        let buffer = self
+            .project
+            .update(cx, |project, cx| project.open_buffer(project_path, cx))?
+            .await?;
+
+        let result = match action {
+            EditAction::Replace {
+                old,
+                new,
+                file_path,
+            } => {
+                let snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot())?;
+
+                cx.background_executor()
+                    .spawn(Self::replace_diff(old, new, file_path, snapshot))
+                    .await
+            }
+            EditAction::Write { content, .. } => Ok(DiffResult::Diff(
+                buffer
+                    .read_with(cx, |buffer, cx| buffer.diff(content, cx))?
+                    .await,
+            )),
+        }?;
+
+        match result {
+            DiffResult::SearchError(error) => {
+                self.push_search_error(error);
+            }
+            DiffResult::Diff(diff) => {
+                let edit_ids = buffer.update(cx, |buffer, cx| {
+                    buffer.finalize_last_transaction();
+                    buffer.apply_diff(diff, false, cx);
+                    let transaction = buffer.finalize_last_transaction();
+                    transaction.map_or(Vec::new(), |transaction| transaction.edit_ids.clone())
+                })?;
+
+                self.push_applied_action(AppliedAction {
+                    source,
+                    buffer,
+                    edit_ids,
+                });
+            }
+        }
+
+        anyhow::Ok(())
+    }
+
+    fn push_search_error(&mut self, error: SearchError) {
+        match &mut self.editor_response {
+            EditorResponse::Message(_) => {
+                self.editor_response = EditorResponse::Actions {
+                    applied: Vec::new(),
+                    search_errors: vec![error],
+                };
+            }
+            EditorResponse::Actions { search_errors, .. } => {
+                search_errors.push(error);
+            }
+        }
+    }
+
+    fn push_applied_action(&mut self, action: AppliedAction) {
+        match &mut self.editor_response {
+            EditorResponse::Message(_) => {
+                self.editor_response = EditorResponse::Actions {
+                    applied: vec![action],
+                    search_errors: Vec::new(),
+                };
+            }
+            EditorResponse::Actions { applied, .. } => {
+                applied.push(action);
+            }
+        }
+    }
+
+    async fn replace_diff(
+        old: String,
+        new: String,
+        file_path: std::path::PathBuf,
+        snapshot: language::BufferSnapshot,
+    ) -> Result<DiffResult> {
+        if snapshot.is_empty() {
+            let exists = snapshot
+                .file()
+                .map_or(false, |file| file.disk_state().exists());
+
+            let error = SearchError::EmptyBuffer {
+                file_path: file_path.display().to_string(),
+                exists,
+                search: old,
+            };
+
+            return Ok(DiffResult::SearchError(error));
+        }
+
+        let replace_result =
+            // Try to match exactly
+            replace_exact(&old, &new, &snapshot)
+            .await
+            // If that fails, try being flexible about indentation
+            .or_else(|| replace_with_flexible_indent(&old, &new, &snapshot));
+
+        let Some(diff) = replace_result else {
+            let error = SearchError::NoMatch {
+                search: old,
+                file_path: file_path.display().to_string(),
+            };
+
+            return Ok(DiffResult::SearchError(error));
+        };
+
+        Ok(DiffResult::Diff(diff))
+    }
+
+    async fn finalize(self, cx: &mut AsyncApp) -> Result<String> {
+        match self.editor_response {
+            EditorResponse::Message(message) => Err(anyhow!(
+                "No edits were applied! You might need to provide more context.\n\n{}",
+                message
+            )),
+            EditorResponse::Actions {
+                applied,
+                search_errors,
+            } => {
+                let mut output = String::with_capacity(1024);
+
+                let parse_errors = self.parser.errors();
+                let has_errors = !search_errors.is_empty() || !parse_errors.is_empty();
+
+                if has_errors {
+                    let error_count = search_errors.len() + parse_errors.len();
+
+                    if applied.is_empty() {
+                        writeln!(
+                            &mut output,
+                            "{} errors occurred! No edits were applied.",
+                            error_count,
+                        )?;
+                    } else {
+                        writeln!(
+                            &mut output,
+                            "{} errors occurred, but {} edits were correctly applied.",
+                            error_count,
+                            applied.len(),
+                        )?;
+
+                        writeln!(
+                            &mut output,
+                            "# {} SEARCH/REPLACE block(s) applied:\n\nDo not re-send these since they are already applied!\n",
+                            applied.len()
+                        )?;
+                    }
+                } else {
+                    write!(
+                        &mut output,
+                        "Successfully applied! Here's a list of applied edits:"
+                    )?;
+                }
+
+                let mut changed_buffers = HashSet::default();
+
+                for action in applied {
+                    changed_buffers.insert(action.buffer.clone());
+                    self.action_log.update(cx, |log, cx| {
+                        log.buffer_edited(action.buffer, action.edit_ids, cx)
+                    })?;
+                    write!(&mut output, "\n\n{}", action.source)?;
+                }
+
+                for buffer in &changed_buffers {
+                    self.project
+                        .update(cx, |project, cx| project.save_buffer(buffer.clone(), cx))?
+                        .await?;
+                }
+
+                if !search_errors.is_empty() {
+                    writeln!(
+                        &mut output,
+                        "\n\n## {} SEARCH/REPLACE block(s) failed to match:\n",
+                        search_errors.len()
+                    )?;
+
+                    for error in search_errors {
+                        match error {
+                            SearchError::NoMatch { file_path, search } => {
+                                writeln!(
+                                    &mut output,
+                                    "### No exact match in: `{}`\n```\n{}\n```\n",
+                                    file_path, search,
+                                )?;
+                            }
+                            SearchError::EmptyBuffer {
+                                file_path,
+                                exists: true,
+                                search,
+                            } => {
+                                writeln!(
+                                    &mut output,
+                                    "### No match because `{}` is empty:\n```\n{}\n```\n",
+                                    file_path, search,
+                                )?;
+                            }
+                            SearchError::EmptyBuffer {
+                                file_path,
+                                exists: false,
+                                search,
+                            } => {
+                                writeln!(
+                                    &mut output,
+                                    "### No match because `{}` does not exist:\n```\n{}\n```\n",
+                                    file_path, search,
+                                )?;
+                            }
+                        }
+                    }
+
+                    write!(
+                        &mut output,
+                        "The SEARCH section must exactly match an existing block of lines including all white \
+                        space, comments, indentation, docstrings, etc."
+                    )?;
+                }
+
+                if !parse_errors.is_empty() {
+                    writeln!(
+                        &mut output,
+                        "\n\n## {} SEARCH/REPLACE blocks failed to parse:",
+                        parse_errors.len()
+                    )?;
+
+                    for error in parse_errors {
+                        writeln!(&mut output, "- {}", error)?;
+                    }
+                }
+
+                if has_errors {
+                    writeln!(
+                        &mut output,
+                        "\n\nYou can fix errors by running the tool again. You can include instructions, \
+                        but errors are part of the conversation so you don't need to repeat them.",
+                    )?;
+
+                    Err(anyhow!(output))
+                } else {
+                    Ok(output)
+                }
+            }
+        }
+    }
+}
--- a/crates/assistant_tools/src/edit_files_tool/description.md
+++ b/crates/assistant_tools/src/edit_files_tool/description.md
@@ -0,0 +1,11 @@
+Edit files in the current project by specifying instructions in natural language.
+
+IMPORTANT NOTE: If there is a find-replace tool, use that instead of this tool! This tool is only to be used as a fallback in case that tool is unavailable. Always prefer that tool if it is available.
+
+When using this tool, you should suggest one coherent edit that can be made to the codebase.
+
+When the set of edits you want to make is large or complex, feel free to invoke this tool multiple times, each time focusing on a specific change you wanna make.
+
+You should use this tool when you want to edit a subset of a file's contents, but not the entire file. You should not use this tool when you want to replace the entire contents of a file with completely different contents, and you absolutely must never use this tool to create new files from scratch. If you ever consider using this tool to create a new file from scratch, for any reason, instead you must reconsider and choose a different approach.
+
+DO NOT call this tool until the code to be edited appears in the conversation! You must use the `read-files` tool or ask the user to add it to context first.
--- a/crates/assistant_tools/src/edit_files_tool/edit_action.rs
+++ b/crates/assistant_tools/src/edit_files_tool/edit_action.rs
@@ -0,0 +1,967 @@
+use std::{
+    mem::take,
+    ops::Range,
+    path::{Path, PathBuf},
+};
+use util::ResultExt;
+
+/// Represents an edit action to be performed on a file.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum EditAction {
+    /// Replace specific content in a file with new content
+    Replace {
+        file_path: PathBuf,
+        old: String,
+        new: String,
+    },
+    /// Write content to a file (create or overwrite)
+    Write { file_path: PathBuf, content: String },
+}
+
+impl EditAction {
+    pub fn file_path(&self) -> &Path {
+        match self {
+            EditAction::Replace { file_path, .. } => file_path,
+            EditAction::Write { file_path, .. } => file_path,
+        }
+    }
+}
+
+/// Parses edit actions from an LLM response.
+/// See system.md for more details on the format.
+#[derive(Debug)]
+pub struct EditActionParser {
+    state: State,
+    line: usize,
+    column: usize,
+    marker_ix: usize,
+    action_source: Vec<u8>,
+    fence_start_offset: usize,
+    block_range: Range<usize>,
+    old_range: Range<usize>,
+    new_range: Range<usize>,
+    errors: Vec<ParseError>,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+enum State {
+    /// Anywhere outside an action
+    Default,
+    /// After opening ```, in optional language tag
+    OpenFence,
+    /// In SEARCH marker
+    SearchMarker,
+    /// In search block or divider
+    SearchBlock,
+    /// In replace block or REPLACE marker
+    ReplaceBlock,
+    /// In closing ```
+    CloseFence,
+}
+
+/// used to avoid having source code that looks like git-conflict markers
+macro_rules! marker_sym {
+    ($char:expr) => {
+        concat!($char, $char, $char, $char, $char, $char, $char)
+    };
+}
+
+const SEARCH_MARKER: &str = concat!(marker_sym!('<'), " SEARCH");
+const DIVIDER: &str = marker_sym!('=');
+const NL_DIVIDER: &str = concat!("\n", marker_sym!('='));
+const REPLACE_MARKER: &str = concat!(marker_sym!('>'), " REPLACE");
+const NL_REPLACE_MARKER: &str = concat!("\n", marker_sym!('>'), " REPLACE");
+const FENCE: &str = "```";
+
+impl EditActionParser {
+    /// Creates a new `EditActionParser`
+    pub fn new() -> Self {
+        Self {
+            state: State::Default,
+            line: 1,
+            column: 0,
+            action_source: Vec::new(),
+            fence_start_offset: 0,
+            marker_ix: 0,
+            block_range: Range::default(),
+            old_range: Range::default(),
+            new_range: Range::default(),
+            errors: Vec::new(),
+        }
+    }
+
+    /// Processes a chunk of input text and returns any completed edit actions.
+    ///
+    /// This method can be called repeatedly with fragments of input. The parser
+    /// maintains its state between calls, allowing you to process streaming input
+    /// as it becomes available. Actions are only inserted once they are fully parsed.
+    ///
+    /// If a block fails to parse, it will simply be skipped and an error will be recorded.
+    /// All errors can be accessed through the `EditActionsParser::errors` method.
+    pub fn parse_chunk(&mut self, input: &str) -> Vec<(EditAction, String)> {
+        use State::*;
+
+        let mut actions = Vec::new();
+
+        for byte in input.bytes() {
+            // Update line and column tracking
+            if byte == b'\n' {
+                self.line += 1;
+                self.column = 0;
+            } else {
+                self.column += 1;
+            }
+
+            let action_offset = self.action_source.len();
+
+            match &self.state {
+                Default => match self.match_marker(byte, FENCE, false) {
+                    MarkerMatch::Complete => {
+                        self.fence_start_offset = action_offset + 1 - FENCE.len();
+                        self.to_state(OpenFence);
+                    }
+                    MarkerMatch::Partial => {}
+                    MarkerMatch::None => {
+                        if self.marker_ix > 0 {
+                            self.marker_ix = 0;
+                        } else if self.action_source.ends_with(b"\n") {
+                            self.action_source.clear();
+                        }
+                    }
+                },
+                OpenFence => {
+                    // skip language tag
+                    if byte == b'\n' {
+                        self.to_state(SearchMarker);
+                    }
+                }
+                SearchMarker => {
+                    if self.expect_marker(byte, SEARCH_MARKER, true) {
+                        self.to_state(SearchBlock);
+                    }
+                }
+                SearchBlock => {
+                    if self.extend_block_range(byte, DIVIDER, NL_DIVIDER) {
+                        self.old_range = take(&mut self.block_range);
+                        self.to_state(ReplaceBlock);
+                    }
+                }
+                ReplaceBlock => {
+                    if self.extend_block_range(byte, REPLACE_MARKER, NL_REPLACE_MARKER) {
+                        self.new_range = take(&mut self.block_range);
+                        self.to_state(CloseFence);
+                    }
+                }
+                CloseFence => {
+                    if self.expect_marker(byte, FENCE, false) {
+                        self.action_source.push(byte);
+
+                        if let Some(action) = self.action() {
+                            actions.push(action);
+                        }
+
+                        self.errors();
+                        self.reset();
+
+                        continue;
+                    }
+                }
+            };
+
+            self.action_source.push(byte);
+        }
+
+        actions
+    }
+
+    /// Returns a reference to the errors encountered during parsing.
+    pub fn errors(&self) -> &[ParseError] {
+        &self.errors
+    }
+
+    fn action(&mut self) -> Option<(EditAction, String)> {
+        let old_range = take(&mut self.old_range);
+        let new_range = take(&mut self.new_range);
+
+        let action_source = take(&mut self.action_source);
+        let action_source = String::from_utf8(action_source).log_err()?;
+
+        let mut file_path_bytes = action_source[..self.fence_start_offset].to_owned();
+
+        if file_path_bytes.ends_with("\n") {
+            file_path_bytes.pop();
+            if file_path_bytes.ends_with("\r") {
+                file_path_bytes.pop();
+            }
+        }
+
+        let file_path = PathBuf::from(file_path_bytes);
+
+        if old_range.is_empty() {
+            return Some((
+                EditAction::Write {
+                    file_path,
+                    content: action_source[new_range].to_owned(),
+                },
+                action_source,
+            ));
+        }
+
+        let old = action_source[old_range].to_owned();
+        let new = action_source[new_range].to_owned();
+
+        let action = EditAction::Replace {
+            file_path,
+            old,
+            new,
+        };
+
+        Some((action, action_source))
+    }
+
+    fn to_state(&mut self, state: State) {
+        self.state = state;
+        self.marker_ix = 0;
+    }
+
+    fn reset(&mut self) {
+        self.action_source.clear();
+        self.block_range = Range::default();
+        self.old_range = Range::default();
+        self.new_range = Range::default();
+        self.fence_start_offset = 0;
+        self.marker_ix = 0;
+        self.to_state(State::Default);
+    }
+
+    fn expect_marker(&mut self, byte: u8, marker: &'static str, trailing_newline: bool) -> bool {
+        match self.match_marker(byte, marker, trailing_newline) {
+            MarkerMatch::Complete => true,
+            MarkerMatch::Partial => false,
+            MarkerMatch::None => {
+                self.errors.push(ParseError {
+                    line: self.line,
+                    column: self.column,
+                    expected: marker,
+                    found: byte,
+                });
+
+                self.reset();
+                false
+            }
+        }
+    }
+
+    fn extend_block_range(&mut self, byte: u8, marker: &str, nl_marker: &str) -> bool {
+        let marker = if self.block_range.is_empty() {
+            // do not require another newline if block is empty
+            marker
+        } else {
+            nl_marker
+        };
+
+        let offset = self.action_source.len();
+
+        match self.match_marker(byte, marker, true) {
+            MarkerMatch::Complete => {
+                if self.action_source[self.block_range.clone()].ends_with(b"\r") {
+                    self.block_range.end -= 1;
+                }
+
+                true
+            }
+            MarkerMatch::Partial => false,
+            MarkerMatch::None => {
+                if self.marker_ix > 0 {
+                    self.marker_ix = 0;
+                    self.block_range.end = offset;
+
+                    // The beginning of marker might match current byte
+                    match self.match_marker(byte, marker, true) {
+                        MarkerMatch::Complete => return true,
+                        MarkerMatch::Partial => return false,
+                        MarkerMatch::None => { /* no match, keep collecting */ }
+                    }
+                }
+
+                if self.block_range.is_empty() {
+                    self.block_range.start = offset;
+                }
+                self.block_range.end = offset + 1;
+
+                false
+            }
+        }
+    }
+
+    fn match_marker(&mut self, byte: u8, marker: &str, trailing_newline: bool) -> MarkerMatch {
+        if trailing_newline && self.marker_ix >= marker.len() {
+            if byte == b'\n' {
+                MarkerMatch::Complete
+            } else if byte == b'\r' {
+                MarkerMatch::Partial
+            } else {
+                MarkerMatch::None
+            }
+        } else if byte == marker.as_bytes()[self.marker_ix] {
+            self.marker_ix += 1;
+
+            if self.marker_ix < marker.len() || trailing_newline {
+                MarkerMatch::Partial
+            } else {
+                MarkerMatch::Complete
+            }
+        } else {
+            MarkerMatch::None
+        }
+    }
+}
+
+#[derive(Debug)]
+enum MarkerMatch {
+    None,
+    Partial,
+    Complete,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct ParseError {
+    line: usize,
+    column: usize,
+    expected: &'static str,
+    found: u8,
+}
+
+impl std::fmt::Display for ParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "input:{}:{}: Expected marker {:?}, found {:?}",
+            self.line, self.column, self.expected, self.found as char
+        )
+    }
+}
+
+pub fn edit_model_prompt() -> String {
+    include_str!("edit_prompt.md")
+        .to_string()
+        .replace("{{SEARCH_MARKER}}", SEARCH_MARKER)
+        .replace("{{DIVIDER}}", DIVIDER)
+        .replace("{{REPLACE_MARKER}}", REPLACE_MARKER)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rand::prelude::*;
+    use util::line_endings;
+
+    const WRONG_MARKER: &str = concat!(marker_sym!('<'), " WRONG_MARKER");
+
+    #[test]
+    fn test_simple_edit_action() {
+        // Construct test input using format with multiline string literals
+        let input = format!(
+            r#"src/main.rs
+```
+{}
+fn original() {{}}
+{}
+fn replacement() {{}}
+{}
+```
+"#,
+            SEARCH_MARKER, DIVIDER, REPLACE_MARKER
+        );
+
+        let mut parser = EditActionParser::new();
+        let actions = parser.parse_chunk(&input);
+
+        assert_no_errors(&parser);
+        assert_eq!(actions.len(), 1);
+        assert_eq!(
+            actions[0].0,
+            EditAction::Replace {
+                file_path: PathBuf::from("src/main.rs"),
+                old: "fn original() {}".to_string(),
+                new: "fn replacement() {}".to_string(),
+            }
+        );
+    }
+
+    #[test]
+    fn test_with_language_tag() {
+        // Construct test input using format with multiline string literals
+        let input = format!(
+            r#"src/main.rs
+```rust
+{}
+fn original() {{}}
+{}
+fn replacement() {{}}
+{}
+```
+"#,
+            SEARCH_MARKER, DIVIDER, REPLACE_MARKER
+        );
+
+        let mut parser = EditActionParser::new();
+        let actions = parser.parse_chunk(&input);
+
+        assert_no_errors(&parser);
+        assert_eq!(actions.len(), 1);
+        assert_eq!(
+            actions[0].0,
+            EditAction::Replace {
+                file_path: PathBuf::from("src/main.rs"),
+                old: "fn original() {}".to_string(),
+                new: "fn replacement() {}".to_string(),
+            }
+        );
+    }
+
+    #[test]
+    fn test_with_surrounding_text() {
+        // Construct test input using format with multiline string literals
+        let input = format!(
+            r#"Here's a modification I'd like to make to the file:
+
+src/main.rs
+```rust
+{}
+fn original() {{}}
+{}
+fn replacement() {{}}
+{}
+```
+
+This change makes the function better.
+"#,
+            SEARCH_MARKER, DIVIDER, REPLACE_MARKER
+        );
+
+        let mut parser = EditActionParser::new();
+        let actions = parser.parse_chunk(&input);
+
+        assert_no_errors(&parser);
+        assert_eq!(actions.len(), 1);
+        assert_eq!(
+            actions[0].0,
+            EditAction::Replace {
+                file_path: PathBuf::from("src/main.rs"),
+                old: "fn original() {}".to_string(),
+                new: "fn replacement() {}".to_string(),
+            }
+        );
+    }
+
+    #[test]
+    fn test_multiple_edit_actions() {
+        // Construct test input using format with multiline string literals
+        let input = format!(
+            r#"First change:
+src/main.rs
+```
+{}
+fn original() {{}}
+{}
+fn replacement() {{}}
+{}
+```
+
+Second change:
+src/utils.rs
+```rust
+{}
+fn old_util() -> bool {{ false }}
+{}
+fn new_util() -> bool {{ true }}
+{}
+```
+"#,
+            SEARCH_MARKER, DIVIDER, REPLACE_MARKER, SEARCH_MARKER, DIVIDER, REPLACE_MARKER
+        );
+
+        let mut parser = EditActionParser::new();
+        let actions = parser.parse_chunk(&input);
+
+        assert_no_errors(&parser);
+        assert_eq!(actions.len(), 2);
+
+        let (action, _) = &actions[0];
+        assert_eq!(
+            action,
+            &EditAction::Replace {
+                file_path: PathBuf::from("src/main.rs"),
+                old: "fn original() {}".to_string(),
+                new: "fn replacement() {}".to_string(),
+            }
+        );
+        let (action2, _) = &actions[1];
+        assert_eq!(
+            action2,
+            &EditAction::Replace {
+                file_path: PathBuf::from("src/utils.rs"),
+                old: "fn old_util() -> bool { false }".to_string(),
+                new: "fn new_util() -> bool { true }".to_string(),
+            }
+        );
+    }
+
+    #[test]
+    fn test_multiline() {
+        // Construct test input using format with multiline string literals
+        let input = format!(
+            r#"src/main.rs
+```rust
+{}
+fn original() {{
+    println!("This is the original function");
+    let x = 42;
+    if x > 0 {{
+        println!("Positive number");
+    }}
+}}
+{}
+fn replacement() {{
+    println!("This is the replacement function");
+    let x = 100;
+    if x > 50 {{
+        println!("Large number");
+    }} else {{
+        println!("Small number");
+    }}
+}}
+{}
+```
+"#,
+            SEARCH_MARKER, DIVIDER, REPLACE_MARKER
+        );
+
+        let mut parser = EditActionParser::new();
+        let actions = parser.parse_chunk(&input);
+
+        assert_no_errors(&parser);
+        assert_eq!(actions.len(), 1);
+
+        let (action, _) = &actions[0];
+        assert_eq!(
+            action,
+            &EditAction::Replace {
+                file_path: PathBuf::from("src/main.rs"),
+                old: "fn original() {\n    println!(\"This is the original function\");\n    let x = 42;\n    if x > 0 {\n        println!(\"Positive number\");\n    }\n}".to_string(),
+                new: "fn replacement() {\n    println!(\"This is the replacement function\");\n    let x = 100;\n    if x > 50 {\n        println!(\"Large number\");\n    } else {\n        println!(\"Small number\");\n    }\n}".to_string(),
+            }
+        );
+    }
+
+    #[test]
+    fn test_write_action() {
+        // Construct test input using format with multiline string literals
+        let input = format!(
+            r#"Create a new main.rs file:
+
+src/main.rs
+```rust
+{}
+{}
+fn new_function() {{
+    println!("This function is being added");
+}}
+{}
+```
+"#,
+            SEARCH_MARKER, DIVIDER, REPLACE_MARKER
+        );
+
+        let mut parser = EditActionParser::new();
+        let actions = parser.parse_chunk(&input);
+
+        assert_no_errors(&parser);
+        assert_eq!(actions.len(), 1);
+        assert_eq!(
+            actions[0].0,
+            EditAction::Write {
+                file_path: PathBuf::from("src/main.rs"),
+                content: "fn new_function() {\n    println!(\"This function is being added\");\n}"
+                    .to_string(),
+            }
+        );
+    }
+
+    #[test]
+    fn test_empty_replace() {
+        // Construct test input using format with multiline string literals
+        let input = format!(
+            r#"src/main.rs
+```rust
+{}
+fn this_will_be_deleted() {{
+    println!("Deleting this function");
+}}
+{}
+{}
+```
+"#,
+            SEARCH_MARKER, DIVIDER, REPLACE_MARKER
+        );
+
+        let mut parser = EditActionParser::new();
+        let actions = parser.parse_chunk(&input);
+
+        assert_no_errors(&parser);
+        assert_eq!(actions.len(), 1);
+        assert_eq!(
+            actions[0].0,
+            EditAction::Replace {
+                file_path: PathBuf::from("src/main.rs"),
+                old: "fn this_will_be_deleted() {\n    println!(\"Deleting this function\");\n}"
+                    .to_string(),
+                new: "".to_string(),
+            }
+        );
+
+        let mut parser = EditActionParser::new();
+        let actions = parser.parse_chunk(&input.replace("\n", "\r\n"));
+        assert_no_errors(&parser);
+        assert_eq!(actions.len(), 1);
+        assert_eq!(
+            actions[0].0,
+            EditAction::Replace {
+                file_path: PathBuf::from("src/main.rs"),
+                old:
+                    "fn this_will_be_deleted() {\r\n    println!(\"Deleting this function\");\r\n}"
+                        .to_string(),
+                new: "".to_string(),
+            }
+        );
+    }
+
+    #[test]
+    fn test_empty_both() {
+        // Construct test input using format with multiline string literals
+        let input = format!(
+            r#"src/main.rs
+```rust
+{}
+{}
+{}
+```
+"#,
+            SEARCH_MARKER, DIVIDER, REPLACE_MARKER
+        );
+
+        let mut parser = EditActionParser::new();
+        let actions = parser.parse_chunk(&input);
+
+        assert_eq!(actions.len(), 1);
+        assert_eq!(
+            actions[0].0,
+            EditAction::Write {
+                file_path: PathBuf::from("src/main.rs"),
+                content: String::new(),
+            }
+        );
+        assert_no_errors(&parser);
+    }
+
+    #[test]
+    fn test_resumability() {
+        // Construct test input using format with multiline string literals
+        let input_part1 = format!("src/main.rs\n```rust\n{}\nfn ori", SEARCH_MARKER);
+
+        let input_part2 = format!("ginal() {{}}\n{}\nfn replacement() {{}}", DIVIDER);
+
+        let input_part3 = format!("\n{}\n```\n", REPLACE_MARKER);
+
+        let mut parser = EditActionParser::new();
+        let actions1 = parser.parse_chunk(&input_part1);
+        assert_no_errors(&parser);
+        assert_eq!(actions1.len(), 0);
+
+        let actions2 = parser.parse_chunk(&input_part2);
+        // No actions should be complete yet
+        assert_no_errors(&parser);
+        assert_eq!(actions2.len(), 0);
+
+        let actions3 = parser.parse_chunk(&input_part3);
+        // The third chunk should complete the action
+        assert_no_errors(&parser);
+        assert_eq!(actions3.len(), 1);
+        let (action, _) = &actions3[0];
+        assert_eq!(
+            action,
+            &EditAction::Replace {
+                file_path: PathBuf::from("src/main.rs"),
+                old: "fn original() {}".to_string(),
+                new: "fn replacement() {}".to_string(),
+            }
+        );
+    }
+
+    #[test]
+    fn test_parser_state_preservation() {
+        let mut parser = EditActionParser::new();
+        let first_chunk = format!("src/main.rs\n```rust\n{}\n", SEARCH_MARKER);
+        let actions1 = parser.parse_chunk(&first_chunk);
+
+        // Check parser is in the correct state
+        assert_no_errors(&parser);
+        assert_eq!(parser.state, State::SearchBlock);
+        assert_eq!(parser.action_source, first_chunk.as_bytes());
+
+        // Continue parsing
+        let second_chunk = format!("original code\n{}\n", DIVIDER);
+        let actions2 = parser.parse_chunk(&second_chunk);
+
+        assert_no_errors(&parser);
+        assert_eq!(parser.state, State::ReplaceBlock);
+        assert_eq!(
+            &parser.action_source[parser.old_range.clone()],
+            b"original code"
+        );
+
+        let third_chunk = format!("replacement code\n{}\n```\n", REPLACE_MARKER);
+        let actions3 = parser.parse_chunk(&third_chunk);
+
+        // After complete parsing, state should reset
+        assert_no_errors(&parser);
+        assert_eq!(parser.state, State::Default);
+        assert_eq!(parser.action_source, b"\n");
+        assert!(parser.old_range.is_empty());
+        assert!(parser.new_range.is_empty());
+
+        assert_eq!(actions1.len(), 0);
+        assert_eq!(actions2.len(), 0);
+        assert_eq!(actions3.len(), 1);
+    }
+
+    #[test]
+    fn test_invalid_search_marker() {
+        let input = format!(
+            r#"src/main.rs
+```rust
+{}
+fn original() {{}}
+{}
+fn replacement() {{}}
+{}
+```
+"#,
+            WRONG_MARKER, DIVIDER, REPLACE_MARKER
+        );
+
+        let mut parser = EditActionParser::new();
+        let actions = parser.parse_chunk(&input);
+        assert_eq!(actions.len(), 0);
+
+        assert_eq!(parser.errors().len(), 1);
+        let error = &parser.errors()[0];
+
+        assert_eq!(
+            error.to_string(),
+            format!(
+                "input:3:9: Expected marker \"{}\", found 'W'",
+                SEARCH_MARKER
+            )
+        );
+    }
+
+    #[test]
+    fn test_missing_closing_fence() {
+        // Construct test input using format with multiline string literals
+        let input = format!(
+            r#"src/main.rs
+```rust
+{}
+fn original() {{}}
+{}
+fn replacement() {{}}
+{}
+<!-- Missing closing fence -->
+
+src/utils.rs
+```rust
+{}
+fn utils_func() {{}}
+{}
+fn new_utils_func() {{}}
+{}
+```
+"#,
+            SEARCH_MARKER, DIVIDER, REPLACE_MARKER, SEARCH_MARKER, DIVIDER, REPLACE_MARKER
+        );
+
+        let mut parser = EditActionParser::new();
+        let actions = parser.parse_chunk(&input);
+
+        // Only the second block should be parsed
+        assert_eq!(actions.len(), 1);
+        let (action, _) = &actions[0];
+        assert_eq!(
+            action,
+            &EditAction::Replace {
+                file_path: PathBuf::from("src/utils.rs"),
+                old: "fn utils_func() {}".to_string(),
+                new: "fn new_utils_func() {}".to_string(),
+            }
+        );
+        assert_eq!(parser.errors().len(), 1);
+        assert_eq!(
+            parser.errors()[0].to_string(),
+            "input:8:1: Expected marker \"```\", found '<'"
+        );
+
+        // The parser should continue after an error
+        assert_eq!(parser.state, State::Default);
+    }
+
+    #[test]
+    fn test_parse_examples_in_edit_prompt() {
+        let mut parser = EditActionParser::new();
+        let actions = parser.parse_chunk(&edit_model_prompt());
+        assert_examples_in_edit_prompt(&actions, parser.errors());
+    }
+
+    #[gpui::test(iterations = 10)]
+    fn test_random_chunking_of_edit_prompt(mut rng: StdRng) {
+        let mut parser = EditActionParser::new();
+        let mut remaining: &str = &edit_model_prompt();
+        let mut actions = Vec::with_capacity(5);
+
+        while !remaining.is_empty() {
+            let chunk_size = rng.gen_range(1..=std::cmp::min(remaining.len(), 100));
+
+            let (chunk, rest) = remaining.split_at(chunk_size);
+
+            let chunk_actions = parser.parse_chunk(chunk);
+            actions.extend(chunk_actions);
+            remaining = rest;
+        }
+
+        assert_examples_in_edit_prompt(&actions, parser.errors());
+    }
+
+    fn assert_examples_in_edit_prompt(actions: &[(EditAction, String)], errors: &[ParseError]) {
+        assert_eq!(actions.len(), 5);
+
+        assert_eq!(
+            actions[0].0,
+            EditAction::Replace {
+                file_path: PathBuf::from("mathweb/flask/app.py"),
+                old: "from flask import Flask".to_string(),
+                new: line_endings!("import math\nfrom flask import Flask").to_string(),
+            },
+        );
+
+        assert_eq!(
+            actions[1].0,
+            EditAction::Replace {
+                file_path: PathBuf::from("mathweb/flask/app.py"),
+                old: line_endings!("def factorial(n):\n    \"compute factorial\"\n\n    if n == 0:\n        return 1\n    else:\n        return n * factorial(n-1)\n").to_string(),
+                new: "".to_string(),
+            }
+        );
+
+        assert_eq!(
+            actions[2].0,
+            EditAction::Replace {
+                file_path: PathBuf::from("mathweb/flask/app.py"),
+                old: "    return str(factorial(n))".to_string(),
+                new: "    return str(math.factorial(n))".to_string(),
+            },
+        );
+
+        assert_eq!(
+            actions[3].0,
+            EditAction::Write {
+                file_path: PathBuf::from("hello.py"),
+                content: line_endings!(
+                    "def hello():\n    \"print a greeting\"\n\n    print(\"hello\")"
+                )
+                .to_string(),
+            },
+        );
+
+        assert_eq!(
+            actions[4].0,
+            EditAction::Replace {
+                file_path: PathBuf::from("main.py"),
+                old: line_endings!(
+                    "def hello():\n    \"print a greeting\"\n\n    print(\"hello\")"
+                )
+                .to_string(),
+                new: "from hello import hello".to_string(),
+            },
+        );
+
+        // The system prompt includes some text that would produce errors
+        assert_eq!(
+            errors[0].to_string(),
+            format!(
+                "input:102:1: Expected marker \"{}\", found '3'",
+                SEARCH_MARKER
+            )
+        );
+        #[cfg(not(windows))]
+        assert_eq!(
+            errors[1].to_string(),
+            format!(
+                "input:109:0: Expected marker \"{}\", found '\\n'",
+                SEARCH_MARKER
+            )
+        );
+        #[cfg(windows)]
+        assert_eq!(
+            errors[1].to_string(),
+            format!(
+                "input:108:1: Expected marker \"{}\", found '\\r'",
+                SEARCH_MARKER
+            )
+        );
+    }
+
+    #[test]
+    fn test_print_error() {
+        let input = format!(
+            r#"src/main.rs
+```rust
+{}
+fn original() {{}}
+{}
+fn replacement() {{}}
+{}
+```
+"#,
+            WRONG_MARKER, DIVIDER, REPLACE_MARKER
+        );
+
+        let mut parser = EditActionParser::new();
+        parser.parse_chunk(&input);
+
+        assert_eq!(parser.errors().len(), 1);
+        let error = &parser.errors()[0];
+        let expected_error = format!(
+            r#"input:3:9: Expected marker "{}", found 'W'"#,
+            SEARCH_MARKER
+        );
+
+        assert_eq!(format!("{}", error), expected_error);
+    }
+
+    // helpers
+
+    fn assert_no_errors(parser: &EditActionParser) {
+        let errors = parser.errors();
+
+        assert!(
+            errors.is_empty(),
+            "Expected no errors, but found:\n\n{}",
+            errors
+                .iter()
+                .map(|e| e.to_string())
+                .collect::<Vec<String>>()
+                .join("\n")
+        );
+    }
+}
--- a/crates/assistant_tools/src/edit_files_tool/edit_prompt.md
+++ b/crates/assistant_tools/src/edit_files_tool/edit_prompt.md
@@ -0,0 +1,134 @@
+Act as an expert software developer.
+Always use best practices when coding.
+Respect and use existing conventions, libraries, etc that are already present in the code base.
+
+Take requests for changes to the supplied code.
+Always reply to the user in the same language they are using.
+
+Once you understand the request, you MUST:
+
+1. Decide if you need to propose *SEARCH/REPLACE* edits to any files that haven't been added to the chat. You can create new files without asking!
+
+2. Think step-by-step and explain the needed changes in a few short sentences.
+
+3. Describe each change with a *SEARCH/REPLACE block* per the examples below.
+
+All changes to files must use this *SEARCH/REPLACE block* format.
+ONLY EVER RETURN CODE IN A *SEARCH/REPLACE BLOCK*!
+
+# Example conversations:
+
+## USER: Change get_factorial() to use math.factorial
+
+## ASSISTANT: To make this change we need to modify `mathweb/flask/app.py` to:
+
+1. Import the math package.
+2. Remove the existing factorial() function.
+3. Update get_factorial() to call math.factorial instead.
+
+Here are the *SEARCH/REPLACE* blocks:
+
+mathweb/flask/app.py
+```python
+{{SEARCH_MARKER}}
+from flask import Flask
+{{DIVIDER}}
+import math
+from flask import Flask
+{{REPLACE_MARKER}}
+```
+
+mathweb/flask/app.py
+```python
+{{SEARCH_MARKER}}
+def factorial(n):
+    "compute factorial"
+
+    if n == 0:
+        return 1
+    else:
+        return n * factorial(n-1)
+
+{{DIVIDER}}
+{{REPLACE_MARKER}}
+```
+
+mathweb/flask/app.py
+```python
+{{SEARCH_MARKER}}
+    return str(factorial(n))
+{{DIVIDER}}
+    return str(math.factorial(n))
+{{REPLACE_MARKER}}
+```
+
+
+## USER: Refactor hello() into its own file.
+
+## ASSISTANT: To make this change we need to modify `main.py` and make a new file `hello.py`:
+
+1. Make a new hello.py file with hello() in it.
+2. Remove hello() from main.py and replace it with an import.
+
+Here are the *SEARCH/REPLACE* blocks:
+
+hello.py
+```python
+{{SEARCH_MARKER}}
+{{DIVIDER}}
+def hello():
+    "print a greeting"
+
+    print("hello")
+{{REPLACE_MARKER}}
+```
+
+main.py
+```python
+{{SEARCH_MARKER}}
+def hello():
+    "print a greeting"
+
+    print("hello")
+{{DIVIDER}}
+from hello import hello
+{{REPLACE_MARKER}}
+```
+# *SEARCH/REPLACE block* Rules:
+
+Every *SEARCH/REPLACE block* must use this format:
+1. The *FULL* file path alone on a line, verbatim. No bold asterisks, no quotes around it, no escaping of characters, etc.
+2. The opening fence and code language, eg: ```python
+3. The start of search block: {{SEARCH_MARKER}}
+4. A contiguous chunk of lines to search for in the existing source code
+5. The dividing line: {{DIVIDER}}
+6. The lines to replace into the source code
+7. The end of the replace block: {{REPLACE_MARKER}}
+8. The closing fence: ```
+
+Use the *FULL* file path, as shown to you by the user. Make sure to include the project's root directory name at the start of the path. *NEVER* specify the absolute path of the file!
+
+Every *SEARCH* section must *EXACTLY MATCH* the existing file content, character for character, including all comments, docstrings, etc.
+If the file contains code or other data wrapped/escaped in json/xml/quotes or other containers, you need to propose edits to the literal contents of the file, including the container markup.
+
+*SEARCH/REPLACE* blocks will *only* replace the first match occurrence.
+Including multiple unique *SEARCH/REPLACE* blocks if needed.
+Include enough lines in each SEARCH section to uniquely match each set of lines that need to change.
+
+Keep *SEARCH/REPLACE* blocks concise.
+Break large *SEARCH/REPLACE* blocks into a series of smaller blocks that each change a small portion of the file.
+Include just the changing lines, and a few surrounding lines if needed for uniqueness.
+Do not include long runs of unchanging lines in *SEARCH/REPLACE* blocks.
+
+Only create *SEARCH/REPLACE* blocks for files that have been read! Even though the conversation includes `read-file` tool results, you *CANNOT* issue your own reads. If the conversation doesn't include the code you need to edit, ask for it to be read explicitly.
+
+To move code within a file, use 2 *SEARCH/REPLACE* blocks: 1 to delete it from its current location, 1 to insert it in the new location.
+
+Pay attention to which filenames the user wants you to edit, especially if they are asking you to create a new file.
+
+If you want to put code in a new file, use a *SEARCH/REPLACE block* with:
+- A new file path, including dir name if needed
+- An empty `SEARCH` section
+- The new file's contents in the `REPLACE` section
+
+ONLY EVER RETURN CODE IN A *SEARCH/REPLACE BLOCK*!
--- a/crates/assistant_tools/src/edit_files_tool/log.rs
+++ b/crates/assistant_tools/src/edit_files_tool/log.rs
@@ -0,0 +1,417 @@
+use std::path::Path;
+
+use collections::HashSet;
+use feature_flags::FeatureFlagAppExt;
+use gpui::{
+    App, Empty, Entity, EventEmitter, FocusHandle, Focusable, Global, ListAlignment, ListState,
+    SharedString, Subscription, Window, actions, list, prelude::*,
+};
+use release_channel::ReleaseChannel;
+use settings::Settings;
+use ui::prelude::*;
+use workspace::{Item, Workspace, WorkspaceId, item::ItemEvent};
+
+use super::edit_action::EditAction;
+
+actions!(debug, [EditTool]);
+
+pub fn init(cx: &mut App) {
+    if cx.is_staff() || ReleaseChannel::global(cx) == ReleaseChannel::Dev {
+        // Track events even before opening the log
+        EditToolLog::global(cx);
+    }
+
+    cx.observe_new(|workspace: &mut Workspace, _, _| {
+        workspace.register_action(|workspace, _: &EditTool, window, cx| {
+            let viewer = cx.new(EditToolLogViewer::new);
+            workspace.add_item_to_active_pane(Box::new(viewer), None, true, window, cx)
+        });
+    })
+    .detach();
+}
+
+pub struct GlobalEditToolLog(Entity<EditToolLog>);
+
+impl Global for GlobalEditToolLog {}
+
+#[derive(Default)]
+pub struct EditToolLog {
+    requests: Vec<EditToolRequest>,
+}
+
+#[derive(Clone, Copy, Hash, Eq, PartialEq)]
+pub struct EditToolRequestId(u32);
+
+impl EditToolLog {
+    pub fn global(cx: &mut App) -> Entity<Self> {
+        match Self::try_global(cx) {
+            Some(entity) => entity,
+            None => {
+                let entity = cx.new(|_cx| Self::default());
+                cx.set_global(GlobalEditToolLog(entity.clone()));
+                entity
+            }
+        }
+    }
+
+    pub fn try_global(cx: &App) -> Option<Entity<Self>> {
+        cx.try_global::<GlobalEditToolLog>()
+            .map(|log| log.0.clone())
+    }
+
+    pub fn new_request(
+        &mut self,
+        instructions: String,
+        cx: &mut Context<Self>,
+    ) -> EditToolRequestId {
+        let id = EditToolRequestId(self.requests.len() as u32);
+        self.requests.push(EditToolRequest {
+            id,
+            instructions,
+            editor_response: None,
+            tool_output: None,
+            parsed_edits: Vec::new(),
+        });
+        cx.emit(EditToolLogEvent::Inserted);
+        id
+    }
+
+    pub fn push_editor_response_chunk(
+        &mut self,
+        id: EditToolRequestId,
+        chunk: &str,
+        new_actions: &[(EditAction, String)],
+        cx: &mut Context<Self>,
+    ) {
+        if let Some(request) = self.requests.get_mut(id.0 as usize) {
+            match &mut request.editor_response {
+                None => {
+                    request.editor_response = Some(chunk.to_string());
+                }
+                Some(response) => {
+                    response.push_str(chunk);
+                }
+            }
+            request
+                .parsed_edits
+                .extend(new_actions.iter().cloned().map(|(action, _)| action));
+
+            cx.emit(EditToolLogEvent::Updated);
+        }
+    }
+
+    pub fn set_tool_output(
+        &mut self,
+        id: EditToolRequestId,
+        tool_output: Result<String, String>,
+        cx: &mut Context<Self>,
+    ) {
+        if let Some(request) = self.requests.get_mut(id.0 as usize) {
+            request.tool_output = Some(tool_output);
+            cx.emit(EditToolLogEvent::Updated);
+        }
+    }
+}
+
+enum EditToolLogEvent {
+    Inserted,
+    Updated,
+}
+
+impl EventEmitter<EditToolLogEvent> for EditToolLog {}
+
+pub struct EditToolRequest {
+    id: EditToolRequestId,
+    instructions: String,
+    // we don't use a result here because the error might have occurred after we got a response
+    editor_response: Option<String>,
+    parsed_edits: Vec<EditAction>,
+    tool_output: Option<Result<String, String>>,
+}
+
+pub struct EditToolLogViewer {
+    focus_handle: FocusHandle,
+    log: Entity<EditToolLog>,
+    list_state: ListState,
+    expanded_edits: HashSet<(EditToolRequestId, usize)>,
+    _subscription: Subscription,
+}
+
+impl EditToolLogViewer {
+    pub fn new(cx: &mut Context<Self>) -> Self {
+        let log = EditToolLog::global(cx);
+
+        let subscription = cx.subscribe(&log, Self::handle_log_event);
+
+        Self {
+            focus_handle: cx.focus_handle(),
+            log: log.clone(),
+            list_state: ListState::new(
+                log.read(cx).requests.len(),
+                ListAlignment::Bottom,
+                px(1024.),
+                {
+                    let this = cx.entity().downgrade();
+                    move |ix, window: &mut Window, cx: &mut App| {
+                        this.update(cx, |this, cx| this.render_request(ix, window, cx))
+                            .unwrap()
+                    }
+                },
+            ),
+            expanded_edits: HashSet::default(),
+            _subscription: subscription,
+        }
+    }
+
+    fn handle_log_event(
+        &mut self,
+        _: Entity<EditToolLog>,
+        event: &EditToolLogEvent,
+        cx: &mut Context<Self>,
+    ) {
+        match event {
+            EditToolLogEvent::Inserted => {
+                let count = self.list_state.item_count();
+                self.list_state.splice(count..count, 1);
+            }
+            EditToolLogEvent::Updated => {}
+        }
+
+        cx.notify();
+    }
+
+    fn render_request(
+        &self,
+        index: usize,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> AnyElement {
+        let requests = &self.log.read(cx).requests;
+        let request = &requests[index];
+
+        v_flex()
+            .gap_3()
+            .child(Self::render_section(IconName::ArrowRight, "Tool Input"))
+            .child(request.instructions.clone())
+            .py_5()
+            .when(index + 1 < requests.len(), |element| {
+                element
+                    .border_b_1()
+                    .border_color(cx.theme().colors().border)
+            })
+            .map(|parent| match &request.editor_response {
+                None => {
+                    if request.tool_output.is_none() {
+                        parent.child("...")
+                    } else {
+                        parent
+                    }
+                }
+                Some(response) => parent
+                    .child(Self::render_section(
+                        IconName::ZedAssistant,
+                        "Editor Response",
+                    ))
+                    .child(Label::new(response.clone()).buffer_font(cx)),
+            })
+            .when(!request.parsed_edits.is_empty(), |parent| {
+                parent
+                    .child(Self::render_section(IconName::Microscope, "Parsed Edits"))
+                    .child(
+                        v_flex()
+                            .gap_2()
+                            .children(request.parsed_edits.iter().enumerate().map(
+                                |(index, edit)| {
+                                    self.render_edit_action(edit, request.id, index, cx)
+                                },
+                            )),
+                    )
+            })
+            .when_some(request.tool_output.as_ref(), |parent, output| {
+                parent
+                    .child(Self::render_section(IconName::ArrowLeft, "Tool Output"))
+                    .child(match output {
+                        Ok(output) => Label::new(output.clone()).color(Color::Success),
+                        Err(error) => Label::new(error.clone()).color(Color::Error),
+                    })
+            })
+            .into_any()
+    }
+
+    fn render_section(icon: IconName, title: &'static str) -> AnyElement {
+        h_flex()
+            .gap_1()
+            .child(Icon::new(icon).color(Color::Muted))
+            .child(Label::new(title).size(LabelSize::Small).color(Color::Muted))
+            .into_any()
+    }
+
+    fn render_edit_action(
+        &self,
+        edit_action: &EditAction,
+        request_id: EditToolRequestId,
+        index: usize,
+        cx: &Context<Self>,
+    ) -> AnyElement {
+        let expanded_id = (request_id, index);
+
+        match edit_action {
+            EditAction::Replace {
+                file_path,
+                old,
+                new,
+            } => self
+                .render_edit_action_container(
+                    expanded_id,
+                    &file_path,
+                    [
+                        Self::render_block(IconName::MagnifyingGlass, "Search", old.clone(), cx)
+                            .border_r_1()
+                            .border_color(cx.theme().colors().border)
+                            .into_any(),
+                        Self::render_block(IconName::Replace, "Replace", new.clone(), cx)
+                            .into_any(),
+                    ],
+                    cx,
+                )
+                .into_any(),
+            EditAction::Write { file_path, content } => self
+                .render_edit_action_container(
+                    expanded_id,
+                    &file_path,
+                    [
+                        Self::render_block(IconName::Pencil, "Write", content.clone(), cx)
+                            .into_any(),
+                    ],
+                    cx,
+                )
+                .into_any(),
+        }
+    }
+
+    fn render_edit_action_container(
+        &self,
+        expanded_id: (EditToolRequestId, usize),
+        file_path: &Path,
+        content: impl IntoIterator<Item = AnyElement>,
+        cx: &Context<Self>,
+    ) -> AnyElement {
+        let is_expanded = self.expanded_edits.contains(&expanded_id);
+
+        v_flex()
+            .child(
+                h_flex()
+                    .bg(cx.theme().colors().element_background)
+                    .border_1()
+                    .border_color(cx.theme().colors().border)
+                    .rounded_t_md()
+                    .when(!is_expanded, |el| el.rounded_b_md())
+                    .py_1()
+                    .px_2()
+                    .gap_1()
+                    .child(
+                        ui::Disclosure::new(ElementId::Integer(expanded_id.1), is_expanded)
+                            .on_click(cx.listener(move |this, _ev, _window, cx| {
+                                if is_expanded {
+                                    this.expanded_edits.remove(&expanded_id);
+                                } else {
+                                    this.expanded_edits.insert(expanded_id);
+                                }
+
+                                cx.notify();
+                            })),
+                    )
+                    .child(Label::new(file_path.display().to_string()).size(LabelSize::Small)),
+            )
+            .child(if is_expanded {
+                h_flex()
+                    .border_1()
+                    .border_t_0()
+                    .border_color(cx.theme().colors().border)
+                    .rounded_b_md()
+                    .children(content)
+                    .into_any()
+            } else {
+                Empty.into_any()
+            })
+            .into_any()
+    }
+
+    fn render_block(icon: IconName, title: &'static str, content: String, cx: &App) -> Div {
+        v_flex()
+            .p_1()
+            .gap_1()
+            .flex_1()
+            .h_full()
+            .child(
+                h_flex()
+                    .gap_1()
+                    .child(Icon::new(icon).color(Color::Muted))
+                    .child(Label::new(title).size(LabelSize::Small).color(Color::Muted)),
+            )
+            .font(theme::ThemeSettings::get_global(cx).buffer_font.clone())
+            .text_sm()
+            .child(content)
+            .child(div().flex_1())
+    }
+}
+
+impl EventEmitter<()> for EditToolLogViewer {}
+
+impl Focusable for EditToolLogViewer {
+    fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Item for EditToolLogViewer {
+    type Event = ();
+
+    fn to_item_events(_: &Self::Event, _: impl FnMut(ItemEvent)) {}
+
+    fn tab_content_text(&self, _window: &Window, _cx: &App) -> Option<SharedString> {
+        Some("Edit Tool Log".into())
+    }
+
+    fn telemetry_event_text(&self) -> Option<&'static str> {
+        None
+    }
+
+    fn clone_on_split(
+        &self,
+        _workspace_id: Option<WorkspaceId>,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Option<Entity<Self>>
+    where
+        Self: Sized,
+    {
+        Some(cx.new(Self::new))
+    }
+}
+
+impl Render for EditToolLogViewer {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        if self.list_state.item_count() == 0 {
+            return v_flex()
+                .justify_center()
+                .size_full()
+                .gap_1()
+                .bg(cx.theme().colors().editor_background)
+                .text_center()
+                .text_lg()
+                .child("No requests yet")
+                .child(
+                    div()
+                        .text_ui(cx)
+                        .child("Go ask the assistant to perform some edits"),
+                );
+        }
+
+        v_flex()
+            .p_4()
+            .bg(cx.theme().colors().editor_background)
+            .size_full()
+            .child(list(self.list_state.clone()).flex_grow())
+    }
+}
--- a/crates/assistant_tools/src/find_replace_file_tool.rs
+++ b/crates/assistant_tools/src/find_replace_file_tool.rs
@@ -1,7 +1,7 @@
 use crate::{replace::replace_with_flexible_indent, schema::json_schema_for};
 use anyhow::{Context as _, Result, anyhow};
 use assistant_tool::{ActionLog, Tool};
-use gpui::{App, AppContext, AsyncApp, Entity, Task};
+use gpui::{App, AppContext, Entity, Task};
 use language_model::{LanguageModelRequestMessage, LanguageModelToolSchemaFormat};
 use project::Project;
 use schemars::JsonSchema;
@@ -126,11 +126,11 @@ pub struct FindReplaceFileTool;

 impl Tool for FindReplaceFileTool {
    fn name(&self) -> String {
-        "find_replace_file".into()
+        "find-replace-file".into()
    }

    fn needs_confirmation(&self) -> bool {
-        false
+        true
    }

    fn description(&self) -> String {
@@ -165,7 +165,7 @@ impl Tool for FindReplaceFileTool {
            Err(err) => return Task::ready(Err(anyhow!(err))),
        };

-        cx.spawn(async move |cx: &mut AsyncApp| {
+        cx.spawn(async move |cx| {
            let project_path = project.read_with(cx, |project, cx| {
                project
                    .find_project_path(&input.path, cx)
@@ -189,22 +189,31 @@ impl Tool for FindReplaceFileTool {
            let result = cx
                .background_spawn(async move {
                    // Try to match exactly
-                    let diff = replace_exact(&input.find, &input.replace, &snapshot)
+                    replace_exact(&input.find, &input.replace, &snapshot)
                    .await
                    // If that fails, try being flexible about indentation
-                    .or_else(|| replace_with_flexible_indent(&input.find, &input.replace, &snapshot))?;
-
-                    if diff.edits.is_empty() {
-                        return None;
-                    }
-
-                    let old_text = snapshot.text();
-
-                    Some((old_text, diff))
+                    .or_else(|| replace_with_flexible_indent(&input.find, &input.replace, &snapshot))
                })
                .await;

-            let Some((old_text, diff)) = result else {
+            if let Some(diff) = result {
+                let edit_ids = buffer.update(cx, |buffer, cx| {
+                    buffer.finalize_last_transaction();
+                    buffer.apply_diff(diff, false, cx);
+                    let transaction = buffer.finalize_last_transaction();
+                    transaction.map_or(Vec::new(), |transaction| transaction.edit_ids.clone())
+                })?;
+
+                action_log.update(cx, |log, cx| {
+                    log.buffer_edited(buffer.clone(), edit_ids, cx)
+                })?;
+
+                project.update(cx, |project, cx| {
+                    project.save_buffer(buffer, cx)
+                })?.await?;
+
+                Ok(format!("Edited {}", input.path.display()))
+            } else {
                let err = buffer.read_with(cx, |buffer, _cx| {
                    let file_exists = buffer
                        .file()
@@ -222,37 +231,8 @@ impl Tool for FindReplaceFileTool {
                    }
                })?;

-                return Err(err)
-            };
-
-            let snapshot = cx.update(|cx| {
-                action_log.update(cx, |log, cx| {
-                    log.buffer_read(buffer.clone(), cx)
-                });
-                let snapshot = buffer.update(cx, |buffer, cx| {
-                    buffer.finalize_last_transaction();
-                    buffer.apply_diff(diff, cx);
-                    buffer.finalize_last_transaction();
-                    buffer.snapshot()
-                });
-                action_log.update(cx, |log, cx| {
-                    log.buffer_edited(buffer.clone(), cx)
-                });
-                snapshot
-            })?;
-
-            project.update( cx, |project, cx| {
-                project.save_buffer(buffer, cx)
-            })?.await?;
-
-            let diff_str = cx.background_spawn(async move {
-                let new_text = snapshot.text();
-                language::unified_diff(&old_text, &new_text)
-            }).await;
-
-
-            Ok(format!("Edited {}:\n\n```diff\n{}\n```", input.path.display(), diff_str))
-
+                Err(err)
+            }
        })
    }
 }
--- a/crates/assistant_tools/src/list_directory_tool.rs
+++ b/crates/assistant_tools/src/list_directory_tool.rs
@@ -41,7 +41,7 @@ pub struct ListDirectoryTool;

 impl Tool for ListDirectoryTool {
    fn name(&self) -> String {
-        "list_directory".into()
+        "list-directory".into()
    }

    fn needs_confirmation(&self) -> bool {
--- a/crates/assistant_tools/src/move_path_tool.rs
+++ b/crates/assistant_tools/src/move_path_tool.rs
@@ -39,7 +39,7 @@ pub struct MovePathTool;

 impl Tool for MovePathTool {
    fn name(&self) -> String {
-        "move_path".into()
+        "move-path".into()
    }

    fn needs_confirmation(&self) -> bool {
--- a/crates/assistant_tools/src/path_search_tool.rs
+++ b/crates/assistant_tools/src/path_search_tool.rs
@@ -38,7 +38,7 @@ pub struct PathSearchTool;

 impl Tool for PathSearchTool {
    fn name(&self) -> String {
-        "path_search".into()
+        "path-search".into()
    }

    fn needs_confirmation(&self) -> bool {
--- a/crates/assistant_tools/src/read_file_tool.rs
+++ b/crates/assistant_tools/src/read_file_tool.rs
@@ -1,6 +1,6 @@
+use std::path::Path;
 use std::sync::Arc;

-use crate::code_symbols_tool::file_outline;
 use crate::schema::json_schema_for;
 use anyhow::{Result, anyhow};
 use assistant_tool::{ActionLog, Tool};
@@ -13,11 +13,6 @@ use serde::{Deserialize, Serialize};
 use ui::IconName;
 use util::markdown::MarkdownString;

-/// If the model requests to read a file whose size exceeds this, then
-/// the tool will return an error along with the model's symbol outline,
-/// and suggest trying again using line ranges from the outline.
-const MAX_FILE_SIZE_TO_READ: usize = 4096;
-
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct ReadFileToolInput {
    /// The relative path of the file to read.
@@ -31,10 +26,10 @@ pub struct ReadFileToolInput {
    /// - directory1
    /// - directory2
    ///
-    /// If you want to access `file.txt` in `directory1`, you should use the path `directory1/file.txt`.
-    /// If you want to access `file.txt` in `directory2`, you should use the path `directory2/file.txt`.
+    /// If you wanna access `file.txt` in `directory1`, you should use the path `directory1/file.txt`.
+    /// If you wanna access `file.txt` in `directory2`, you should use the path `directory2/file.txt`.
    /// </example>
-    pub path: String,
+    pub path: Arc<Path>,

    /// Optional line number to start reading on (1-based index)
    #[serde(default)]
@@ -49,7 +44,7 @@ pub struct ReadFileTool;

 impl Tool for ReadFileTool {
    fn name(&self) -> String {
-        "read_file".into()
+        "read-file".into()
    }

    fn needs_confirmation(&self) -> bool {
@@ -71,12 +66,8 @@ impl Tool for ReadFileTool {
    fn ui_text(&self, input: &serde_json::Value) -> String {
        match serde_json::from_value::<ReadFileToolInput>(input.clone()) {
            Ok(input) => {
-                let path = MarkdownString::inline_code(&input.path);
-                match (input.start_line, input.end_line) {
-                    (Some(start), None) => format!("Read file {path} (from line {start})"),
-                    (Some(start), Some(end)) => format!("Read file {path} (lines {start}-{end})"),
-                    _ => format!("Read file {path}"),
-                }
+                let path = MarkdownString::inline_code(&input.path.display().to_string());
+                format!("Read file {path}")
            }
            Err(_) => "Read file".to_string(),
        }
@@ -96,10 +87,12 @@ impl Tool for ReadFileTool {
        };

        let Some(project_path) = project.read(cx).find_project_path(&input.path, cx) else {
-            return Task::ready(Err(anyhow!("Path {} not found in project", &input.path,)));
+            return Task::ready(Err(anyhow!(
+                "Path {} not found in project",
+                &input.path.display()
+            )));
        };

-        let file_path = input.path.clone();
        cx.spawn(async move |cx| {
            let buffer = cx
                .update(|cx| {
@@ -107,46 +100,27 @@ impl Tool for ReadFileTool {
                })?
                .await?;

-            // Check if specific line ranges are provided
-            if input.start_line.is_some() || input.end_line.is_some() {
-                let result = buffer.read_with(cx, |buffer, _cx| {
-                    let text = buffer.text();
+            let result = buffer.read_with(cx, |buffer, _cx| {
+                let text = buffer.text();
+                if input.start_line.is_some() || input.end_line.is_some() {
                    let start = input.start_line.unwrap_or(1);
                    let lines = text.split('\n').skip(start - 1);
                    if let Some(end) = input.end_line {
-                        let count = end.saturating_sub(start).max(1); // Ensure at least 1 line
+                        let count = end.saturating_sub(start);
                        Itertools::intersperse(lines.take(count), "\n").collect()
                    } else {
                        Itertools::intersperse(lines, "\n").collect()
                    }
-                })?;
-
-                action_log.update(cx, |log, cx| {
-                    log.buffer_read(buffer, cx);
-                })?;
-
-                Ok(result)
-            } else {
-                // No line ranges specified, so check file size to see if it's too big.
-                let file_size = buffer.read_with(cx, |buffer, _cx| buffer.text().len())?;
-
-                if file_size <= MAX_FILE_SIZE_TO_READ {
-                    // File is small enough, so return its contents.
-                    let result = buffer.read_with(cx, |buffer, _cx| buffer.text())?;
-
-                    action_log.update(cx, |log, cx| {
-                        log.buffer_read(buffer, cx);
-                    })?;
-
-                    Ok(result)
                } else {
-                    // File is too big, so return an error with the outline
-                    // and a suggestion to read again with line numbers.
-                    let outline = file_outline(project, file_path, action_log, None, 0, cx).await?;
-
-                    Ok(format!("This file was too big to read all at once. Here is an outline of its symbols:\n\n{outline}\n\nUsing the line numbers in this outline, you can call this tool again while specifying the start_line and end_line fields to see the implementations of symbols in the outline."))
+                    text
                }
-            }
+            })?;
+
+            action_log.update(cx, |log, cx| {
+                log.buffer_read(buffer, cx);
+            })?;
+
+            anyhow::Ok(result)
        })
    }
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Ben Kunkle	b06459ee00	helix paste (wip)	2025-04-01 16:32:42 -05:00
Ben Kunkle	db7425e264	helix yank (wip)	2025-04-01 16:32:31 -05:00
Ben Kunkle	704bcf96ba	Handle Motion::CurrentLine in vim Mode::HelixNormal	2025-04-01 16:28:35 -05:00
				`@@ -1 +0,0 @@`
				`<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-check-check-icon lucide-check-check"><path d="M18 6 7 17l-5-5"/><path d="m22 10-7.5 7.5L13 16"/></svg>`