add element id in item render_page items instead

upper case all lsp references in titles and descriptions
Fix some settings ui elements having duplicate ids
2025-10-09 12:43:24 -04:00 · 2025-10-09 12:33:41 -04:00 · 2025-10-09 12:29:21 -04:00 · 2025-10-09 12:02:56 -04:00 · 2025-10-09 11:16:43 -04:00 · 2025-10-09 11:12:09 -04:00
608 changed files with 131535 additions and 15695 deletions
--- a/.config/hakari.toml
+++ b/.config/hakari.toml
@@ -24,7 +24,7 @@ workspace-members = [
 third-party = [
    { name = "reqwest", version = "0.11.27" },
    # build of remote_server should not include scap / its x11 dependency
-    { name = "scap", git = "https://github.com/zed-industries/scap", rev = "808aa5c45b41e8f44729d02e38fd00a2fe2722e7" },
+    { name = "zed-scap", git = "https://github.com/zed-industries/scap", rev = "4afea48c3b002197176fb19cd0f9b180dd36eaac", version = "0.0.8-zed" },
    # build of remote_server should not need to include on libalsa through rodio
    { name = "rodio", git = "https://github.com/RustAudio/rodio" },
 ]
@@ -37,8 +37,6 @@ workspace-members = [
    "zed_glsl",
    "zed_html",
    "zed_proto",
-    "zed_ruff",
    "slash_commands_example",
-    "zed_snippets",
    "zed_test_extension",
 ]
--- a/.github/actions/run_tests/action.yml
+++ b/.github/actions/run_tests/action.yml
@@ -20,4 +20,4 @@ runs:

    - name: Run tests
      shell: bash -euxo pipefail {0}
-      run: cargo nextest run --workspace --no-fail-fast
+      run: cargo nextest run --workspace --no-fail-fast --failure-output immediate-final
--- a/.github/actions/run_tests_windows/action.yml
+++ b/.github/actions/run_tests_windows/action.yml
@@ -24,4 +24,4 @@ runs:
      shell: powershell
      working-directory: ${{ inputs.working-directory }}
      run: |
-        cargo nextest run --workspace --no-fail-fast
+        cargo nextest run --workspace --no-fail-fast --failure-output immediate-final
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -826,8 +826,9 @@ jobs:
    timeout-minutes: 120
    name: Create a Windows installer
    runs-on: [self-32vcpu-windows-2022]
-    if: contains(github.event.pull_request.labels.*.name, 'run-bundling')
-    # if: (startsWith(github.ref, 'refs/tags/v') || contains(github.event.pull_request.labels.*.name, 'run-bundling'))
+    if: |
+      ( startsWith(github.ref, 'refs/tags/v')
+      || contains(github.event.pull_request.labels.*.name, 'run-bundling') )
    needs: [windows_tests]
    env:
      AZURE_TENANT_ID: ${{ secrets.AZURE_SIGNING_TENANT_ID }}
@@ -870,8 +871,7 @@ jobs:

      - name: Upload Artifacts to release
        uses: softprops/action-gh-release@de2c0eb89ae2a093876385947365aca7b0e5f844 # v1
-        # Re-enable when we are ready to publish windows preview releases
-        if: ${{ !(contains(github.event.pull_request.labels.*.name, 'run-bundling')) && env.RELEASE_CHANNEL == 'preview' }} # upload only preview
+        if: ${{ !(contains(github.event.pull_request.labels.*.name, 'run-bundling')) }}
        with:
          draft: true
          prerelease: ${{ env.RELEASE_CHANNEL == 'preview' }}
--- a/.github/workflows/community_release_actions.yml
+++ b/.github/workflows/community_release_actions.yml
@@ -39,7 +39,7 @@ jobs:
          content: ${{ steps.get-content.outputs.string }}

  send_release_notes_email:
-    if: github.repository_owner == 'zed-industries' && !github.event.release.prerelease
+    if: false && github.repository_owner == 'zed-industries' && !github.event.release.prerelease
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
--- a/.github/workflows/issue_response.yml
+++ b/.github/workflows/issue_response.yml
@@ -1,33 +0,0 @@
-name: Issue Response
-
-on:
-  schedule:
-    - cron: "0 12 * * 2"
-  workflow_dispatch:
-
-jobs:
-  issue-response:
-    if: github.repository_owner == 'zed-industries'
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
-
-      - uses: pnpm/action-setup@fe02b34f77f8bc703788d5817da081398fad5dd2 # v4.0.0
-        with:
-          version: 9
-
-      - name: Setup Node
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
-        with:
-          node-version: "20"
-          cache: "pnpm"
-          cache-dependency-path: "script/issue_response/pnpm-lock.yaml"
-
-      - run: pnpm install --dir script/issue_response
-
-      - name: Run Issue Response
-        run: pnpm run --dir script/issue_response start
-        env:
-          ISSUE_RESPONSE_GITHUB_TOKEN: ${{ secrets.ISSUE_RESPONSE_GITHUB_TOKEN }}
-          SLACK_ISSUE_RESPONSE_WEBHOOK_URL: ${{ secrets.SLACK_ISSUE_RESPONSE_WEBHOOK_URL }}
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -63,6 +63,7 @@ Although there are few hard and fast rules, typically we don't merge:
 - New file icons. Zed's default icon theme consists of icons that are hand-designed to fit together in a cohesive manner, please don't submit PRs with off-the-shelf SVGs.
 - Giant refactorings.
 - Non-trivial changes with no tests.
+- Stylistic code changes that do not alter any app logic. Reducing allocations, removing `.unwrap()`s, fixing typos is great; making code "more readable" — maybe not so much.
 - Features where (in our subjective opinion) the extra complexity isn't worth it for the number of people who will benefit.
 - Anything that seems completely AI generated.

--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -164,6 +164,7 @@ members = [
    "crates/sum_tree",
    "crates/supermaven",
    "crates/supermaven_api",
+    "crates/codestral",
    "crates/svg_preview",
    "crates/system_specs",
    "crates/tab_switcher",
@@ -212,9 +213,7 @@ members = [
    "extensions/glsl",
    "extensions/html",
    "extensions/proto",
-    "extensions/ruff",
    "extensions/slash-commands-example",
-    "extensions/snippets",
    "extensions/test-extension",

    #
@@ -275,7 +274,7 @@ cloud_llm_client = { path = "crates/cloud_llm_client" }
 cloud_zeta2_prompt = { path = "crates/cloud_zeta2_prompt" }
 collab = { path = "crates/collab" }
 collab_ui = { path = "crates/collab_ui" }
-collections = { path = "crates/collections" }
+collections = { path = "crates/collections", package = "zed-collections", version = "0.1.0" }
 command_palette = { path = "crates/command_palette" }
 command_palette_hooks = { path = "crates/command_palette_hooks" }
 component = { path = "crates/component" }
@@ -291,6 +290,7 @@ debug_adapter_extension = { path = "crates/debug_adapter_extension" }
 debugger_tools = { path = "crates/debugger_tools" }
 debugger_ui = { path = "crates/debugger_ui" }
 deepseek = { path = "crates/deepseek" }
+derive_refineable = { path = "crates/refineable/derive_refineable", package = "zed-derive-refineable", version = "0.1.0" }
 diagnostics = { path = "crates/diagnostics" }
 editor = { path = "crates/editor" }
 extension = { path = "crates/extension" }
@@ -309,10 +309,10 @@ git_ui = { path = "crates/git_ui" }
 go_to_line = { path = "crates/go_to_line" }
 google_ai = { path = "crates/google_ai" }
 gpui = { path = "crates/gpui", default-features = false }
-gpui_macros = { path = "crates/gpui_macros" }
+gpui_macros = { path = "crates/gpui_macros", package = "gpui-macros", version = "0.1.0" }
 gpui_tokio = { path = "crates/gpui_tokio" }
 html_to_markdown = { path = "crates/html_to_markdown" }
-http_client = { path = "crates/http_client" }
+http_client = { path = "crates/http_client", package = "zed-http-client", version = "0.1.0" }
 http_client_tls = { path = "crates/http_client_tls" }
 icons = { path = "crates/icons" }
 image_viewer = { path = "crates/image_viewer" }
@@ -341,7 +341,7 @@ lsp = { path = "crates/lsp" }
 markdown = { path = "crates/markdown" }
 markdown_preview = { path = "crates/markdown_preview" }
 svg_preview = { path = "crates/svg_preview" }
-media = { path = "crates/media" }
+media = { path = "crates/media", package = "zed-media", version = "0.1.0" }
 menu = { path = "crates/menu" }
 migrator = { path = "crates/migrator" }
 mistral = { path = "crates/mistral" }
@@ -358,7 +358,7 @@ outline = { path = "crates/outline" }
 outline_panel = { path = "crates/outline_panel" }
 panel = { path = "crates/panel" }
 paths = { path = "crates/paths" }
-perf = { path = "tooling/perf" }
+perf = { path = "tooling/perf", package = "zed-perf", version = "0.1.0" }
 picker = { path = "crates/picker" }
 plugin = { path = "crates/plugin" }
 plugin_macros = { path = "crates/plugin_macros" }
@@ -370,7 +370,7 @@ project_symbols = { path = "crates/project_symbols" }
 prompt_store = { path = "crates/prompt_store" }
 proto = { path = "crates/proto" }
 recent_projects = { path = "crates/recent_projects" }
-refineable = { path = "crates/refineable" }
+refineable = { path = "crates/refineable", package = "zed-refineable", version = "0.1.0" }
 release_channel = { path = "crates/release_channel" }
 scheduler = { path = "crates/scheduler" }
 remote = { path = "crates/remote" }
@@ -378,12 +378,12 @@ remote_server = { path = "crates/remote_server" }
 repl = { path = "crates/repl" }
 reqwest_client = { path = "crates/reqwest_client" }
 rich_text = { path = "crates/rich_text" }
-rodio = { git = "https://github.com/RustAudio/rodio", rev = "be453f2" }
+rodio = { git = "https://github.com/RustAudio/rodio" }
 rope = { path = "crates/rope" }
 rpc = { path = "crates/rpc" }
 rules_library = { path = "crates/rules_library" }
 search = { path = "crates/search" }
-semantic_version = { path = "crates/semantic_version" }
+semantic_version = { path = "crates/semantic_version", package = "zed-semantic-version", version = "0.1.0" }
 session = { path = "crates/session" }
 settings = { path = "crates/settings" }
 settings_macros = { path = "crates/settings_macros" }
@@ -396,9 +396,10 @@ sqlez_macros = { path = "crates/sqlez_macros" }
 story = { path = "crates/story" }
 storybook = { path = "crates/storybook" }
 streaming_diff = { path = "crates/streaming_diff" }
-sum_tree = { path = "crates/sum_tree" }
+sum_tree = { path = "crates/sum_tree", package = "zed-sum-tree", version = "0.1.0" }
 supermaven = { path = "crates/supermaven" }
 supermaven_api = { path = "crates/supermaven_api" }
+codestral = { path = "crates/codestral" }
 system_specs = { path = "crates/system_specs" }
 tab_switcher = { path = "crates/tab_switcher" }
 task = { path = "crates/task" }
@@ -419,8 +420,8 @@ ui = { path = "crates/ui" }
 ui_input = { path = "crates/ui_input" }
 ui_macros = { path = "crates/ui_macros" }
 ui_prompt = { path = "crates/ui_prompt" }
-util = { path = "crates/util" }
-util_macros = { path = "crates/util_macros" }
+util = { path = "crates/util", package = "zed-util", version = "0.1.0" }
+util_macros = { path = "crates/util_macros", package = "zed-util-macros", version = "0.1.0" }
 vercel = { path = "crates/vercel" }
 vim = { path = "crates/vim" }
 vim_mode_setting = { path = "crates/vim_mode_setting" }
@@ -474,10 +475,9 @@ backtrace = "0.3"
 base64 = "0.22"
 bincode = "1.2.1"
 bitflags = "2.6.0"
-blade-graphics = { git = "https://github.com/kvark/blade", rev = "bfa594ea697d4b6326ea29f747525c85ecf933b9" }
-blade-macros = { git = "https://github.com/kvark/blade", rev = "bfa594ea697d4b6326ea29f747525c85ecf933b9" }
-blade-util = { git = "https://github.com/kvark/blade", rev = "bfa594ea697d4b6326ea29f747525c85ecf933b9" }
-blake3 = "1.5.3"
+blade-graphics = { version = "0.7.0" }
+blade-macros = { version = "0.3.0" }
+blade-util = { version = "0.3.0" }
 bytes = "1.0"
 cargo_metadata = "0.19"
 cargo_toml = "0.21"
@@ -550,6 +550,7 @@ nanoid = "0.4"
 nbformat = {  git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734" }
 nix = "0.29"
 num-format = "0.4.4"
+num-traits = "0.2"
 objc = "0.2"
 objc2-foundation = { version = "0.3", default-features = false, features = [
    "NSArray",
@@ -604,10 +605,10 @@ pulldown-cmark = { version = "0.12.0", default-features = false }
 quote = "1.0.9"
 rand = "0.9"
 rayon = "1.8"
-realfft = "3.4.0"
 ref-cast = "1.0.24"
 regex = "1.5"
-reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "951c770a32f1998d6e999cef3e59e0013e6c4415", default-features = false, features = [
+# WARNING: If you change this, you must also publish a new version of zed-reqwest to crates.io
+reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "c15662463bda39148ba154100dd44d3fba5873a4", default-features = false, features = [
    "charset",
    "http2",
    "macos-system-configuration",
@@ -615,18 +616,17 @@ reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "951c77
    "rustls-tls-native-roots",
    "socks",
    "stream",
-] }
+], package = "zed-reqwest", version = "0.12.15-zed" }
 rsa = "0.9.6"
 runtimelib = {  git = "https://github.com/ConradIrwin/runtimed", rev = "7130c804216b6914355d15d0b91ea91f6babd734", default-features = false, features = [
    "async-dispatcher-runtime",
 ] }
 rust-embed = { version = "8.4", features = ["include-exclude"] }
-rustc-demangle = "0.1.23"
 rustc-hash = "2.1.0"
-rustfft = { version = "6.2.0", features = ["avx"] }
 rustls = { version = "0.23.26" }
 rustls-platform-verifier = "0.5.0"
-scap = { git = "https://github.com/zed-industries/scap", rev = "808aa5c45b41e8f44729d02e38fd00a2fe2722e7", default-features = false }
+# WARNING: If you change this, you must also publish a new version of zed-scap to crates.io
+scap = { git = "https://github.com/zed-industries/scap", rev = "4afea48c3b002197176fb19cd0f9b180dd36eaac", default-features = false, package = "zed-scap", version = "0.0.8-zed" }
 schemars = { version = "1.0", features = ["indexmap2"] }
 semver = "1.0"
 serde = { version = "1.0.221", features = ["derive", "rc"] }
@@ -652,7 +652,7 @@ streaming-iterator = "0.1"
 strsim = "0.11"
 strum = { version = "0.27.0", features = ["derive"] }
 subtle = "2.5.0"
-syn = { version = "2.0.101", features = ["full", "extra-traits"] }
+syn = { version = "2.0.101", features = ["full", "extra-traits", "visit-mut"] }
 sys-locale = "0.3.1"
 sysinfo = "0.31.0"
 take-until = "0.2.0"
@@ -670,8 +670,9 @@ tiny_http = "0.8"
 tokio = { version = "1" }
 tokio-tungstenite = { version = "0.26", features = ["__rustls-tls"] }
 toml = "0.8"
+toml_edit = { version = "0.22", default-features = false, features = ["display", "parse", "serde"] }
 tower-http = "0.4.4"
-tree-sitter = { version = "0.25.6", features = ["wasm"] }
+tree-sitter = { version = "0.25.10", features = ["wasm"] }
 tree-sitter-bash = "0.25.0"
 tree-sitter-c = "0.23"
 tree-sitter-cpp = { git = "https://github.com/tree-sitter/tree-sitter-cpp", rev = "5cb9b693cfd7bfacab1d9ff4acac1a4150700609" }
@@ -688,11 +689,11 @@ tree-sitter-html = "0.23"
 tree-sitter-jsdoc = "0.23"
 tree-sitter-json = "0.24"
 tree-sitter-md = { git = "https://github.com/tree-sitter-grammars/tree-sitter-markdown", rev = "9a23c1a96c0513d8fc6520972beedd419a973539" }
-tree-sitter-python = { git = "https://github.com/zed-industries/tree-sitter-python", rev = "218fcbf3fda3d029225f3dec005cb497d111b35e" }
+tree-sitter-python = "0.25"
 tree-sitter-regex = "0.24"
 tree-sitter-ruby = "0.23"
 tree-sitter-rust = "0.24"
-tree-sitter-typescript = "0.23"
+tree-sitter-typescript = { git = "https://github.com/zed-industries/tree-sitter-typescript", rev = "e2c53597d6a5d9cf7bbe8dccde576fe1e46c5899" } # https://github.com/tree-sitter/tree-sitter-typescript/pull/347
 tree-sitter-yaml = { git = "https://github.com/zed-industries/tree-sitter-yaml", rev = "baff0b51c64ef6a1fb1f8390f3ad6015b83ec13a" }
 unicase = "2.6"
 unicode-script = "0.5.7"
@@ -804,7 +805,7 @@ wasmtime = { opt-level = 3 }
 activity_indicator = { codegen-units = 1 }
 assets = { codegen-units = 1 }
 breadcrumbs = { codegen-units = 1 }
-collections = { codegen-units = 1 }
+zed-collections = { codegen-units = 1 }
 command_palette = { codegen-units = 1 }
 command_palette_hooks = { codegen-units = 1 }
 extension_cli = { codegen-units = 1 }
@@ -824,11 +825,11 @@ outline = { codegen-units = 1 }
 paths = { codegen-units = 1 }
 prettier = { codegen-units = 1 }
 project_symbols = { codegen-units = 1 }
-refineable = { codegen-units = 1 }
+zed-refineable = { codegen-units = 1 }
 release_channel = { codegen-units = 1 }
 reqwest_client = { codegen-units = 1 }
 rich_text = { codegen-units = 1 }
-semantic_version = { codegen-units = 1 }
+zed-semantic-version = { codegen-units = 1 }
 session = { codegen-units = 1 }
 snippet = { codegen-units = 1 }
 snippets_ui = { codegen-units = 1 }
--- a/GEMINI.md
+++ b/GEMINI.md
@@ -0,0 +1 @@
+.rules
--- a/assets/icons/paperclip.svg
+++ b/assets/icons/paperclip.svg
@@ -0,0 +1,3 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M10.1645 4.45825L5.20344 9.52074C4.98225 9.74193 4.85798 10.0419 4.85798 10.3548C4.85798 10.6676 4.98225 10.9676 5.20344 11.1888C5.42464 11.41 5.72464 11.5342 6.03746 11.5342C6.35028 11.5342 6.65028 11.41 6.87148 11.1888L11.8326 6.12629C12.2749 5.68397 12.5234 5.08407 12.5234 4.45854C12.5234 3.83302 12.2749 3.23311 11.8326 2.7908C11.3902 2.34849 10.7903 2.1 10.1648 2.1C9.53928 2.1 8.93938 2.34849 8.49707 2.7908L3.55663 7.83265C3.22373 8.16017 2.95897 8.55037 2.77762 8.98072C2.59628 9.41108 2.50193 9.87308 2.50003 10.3401C2.49813 10.8071 2.58871 11.2698 2.76654 11.7017C2.94438 12.1335 3.20595 12.5258 3.53618 12.856C3.8664 13.1863 4.25873 13.4478 4.69055 13.6257C5.12237 13.8035 5.58513 13.8941 6.05213 13.8922C6.51913 13.8903 6.98114 13.7959 7.41149 13.6146C7.84185 13.4332 8.23204 13.1685 8.55957 12.8356L13.5 7.79373" stroke="#C4CAD4" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -30,7 +30,8 @@
      "ctrl-+": ["zed::IncreaseBufferFontSize", { "persist": false }],
      "ctrl--": ["zed::DecreaseBufferFontSize", { "persist": false }],
      "ctrl-0": ["zed::ResetBufferFontSize", { "persist": false }],
-      "ctrl-,": "zed::OpenSettings",
+      "ctrl-,": "zed::OpenSettingsEditor",
+      "ctrl-alt-,": "zed::OpenSettings",
      "ctrl-q": "zed::Quit",
      "f4": "debugger::Start",
      "shift-f5": "debugger::Stop",
@@ -250,7 +251,7 @@
      "alt-enter": "agent::ContinueWithBurnMode",
      "ctrl-y": "agent::AllowOnce",
      "ctrl-alt-y": "agent::AllowAlways",
-      "ctrl-d": "agent::RejectOnce"
+      "ctrl-alt-z": "agent::RejectOnce"
    }
  },
  {
@@ -369,7 +370,8 @@
    "bindings": {
      "new": "rules_library::NewRule",
      "ctrl-n": "rules_library::NewRule",
-      "ctrl-shift-s": "rules_library::ToggleDefaultRule"
+      "ctrl-shift-s": "rules_library::ToggleDefaultRule",
+      "ctrl-w": "workspace::CloseWindow"
    }
  },
  {
@@ -525,15 +527,15 @@
      "ctrl-k ctrl-l": "editor::ToggleFold",
      "ctrl-k ctrl-[": "editor::FoldRecursive",
      "ctrl-k ctrl-]": "editor::UnfoldRecursive",
-      "ctrl-k ctrl-1": ["editor::FoldAtLevel", 1],
-      "ctrl-k ctrl-2": ["editor::FoldAtLevel", 2],
-      "ctrl-k ctrl-3": ["editor::FoldAtLevel", 3],
-      "ctrl-k ctrl-4": ["editor::FoldAtLevel", 4],
-      "ctrl-k ctrl-5": ["editor::FoldAtLevel", 5],
-      "ctrl-k ctrl-6": ["editor::FoldAtLevel", 6],
-      "ctrl-k ctrl-7": ["editor::FoldAtLevel", 7],
-      "ctrl-k ctrl-8": ["editor::FoldAtLevel", 8],
-      "ctrl-k ctrl-9": ["editor::FoldAtLevel", 9],
+      "ctrl-k ctrl-1": "editor::FoldAtLevel_1",
+      "ctrl-k ctrl-2": "editor::FoldAtLevel_2",
+      "ctrl-k ctrl-3": "editor::FoldAtLevel_3",
+      "ctrl-k ctrl-4": "editor::FoldAtLevel_4",
+      "ctrl-k ctrl-5": "editor::FoldAtLevel_5",
+      "ctrl-k ctrl-6": "editor::FoldAtLevel_6",
+      "ctrl-k ctrl-7": "editor::FoldAtLevel_7",
+      "ctrl-k ctrl-8": "editor::FoldAtLevel_8",
+      "ctrl-k ctrl-9": "editor::FoldAtLevel_9",
      "ctrl-k ctrl-0": "editor::FoldAll",
      "ctrl-k ctrl-j": "editor::UnfoldAll",
      "ctrl-space": "editor::ShowCompletions",
@@ -1227,9 +1229,6 @@
    "context": "Onboarding",
    "use_key_equivalents": true,
    "bindings": {
-      "ctrl-1": "onboarding::ActivateBasicsPage",
-      "ctrl-2": "onboarding::ActivateEditingPage",
-      "ctrl-3": "onboarding::ActivateAISetupPage",
      "ctrl-enter": "onboarding::Finish",
      "alt-shift-l": "onboarding::SignIn",
      "alt-shift-a": "onboarding::OpenAccount"
@@ -1241,5 +1240,41 @@
    "bindings": {
      "ctrl-shift-enter": "workspace::OpenWithSystem"
    }
+  },
+  {
+    "context": "SettingsWindow",
+    "use_key_equivalents": true,
+    "bindings": {
+      "ctrl-w": "workspace::CloseWindow",
+      "escape": "workspace::CloseWindow",
+      "ctrl-m": "settings_editor::Minimize",
+      "ctrl-f": "search::FocusSearch",
+      "ctrl-shift-e": "settings_editor::ToggleFocusNav",
+      // todo(settings_ui): cut this down based on the max files and overflow UI
+      "ctrl-1": ["settings_editor::FocusFile", 0],
+      "ctrl-2": ["settings_editor::FocusFile", 1],
+      "ctrl-3": ["settings_editor::FocusFile", 2],
+      "ctrl-4": ["settings_editor::FocusFile", 3],
+      "ctrl-5": ["settings_editor::FocusFile", 4],
+      "ctrl-6": ["settings_editor::FocusFile", 5],
+      "ctrl-7": ["settings_editor::FocusFile", 6],
+      "ctrl-8": ["settings_editor::FocusFile", 7],
+      "ctrl-9": ["settings_editor::FocusFile", 8],
+      "ctrl-0": ["settings_editor::FocusFile", 9],
+      "ctrl-pageup": "settings_editor::FocusPreviousFile",
+      "ctrl-pagedown": "settings_editor::FocusNextFile"
+    }
+  },
+  {
+    "context": "SettingsWindow > NavigationMenu",
+    "use_key_equivalents": true,
+    "bindings": {
+      "right": "settings_editor::ExpandNavEntry",
+      "left": "settings_editor::CollapseNavEntry",
+      "pageup": "settings_editor::FocusPreviousRootNavEntry",
+      "pagedown": "settings_editor::FocusNextRootNavEntry",
+      "home": "settings_editor::FocusFirstNavEntry",
+      "end": "settings_editor::FocusLastNavEntry"
+    }
  }
 ]
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -39,7 +39,8 @@
      "cmd-+": ["zed::IncreaseBufferFontSize", { "persist": false }],
      "cmd--": ["zed::DecreaseBufferFontSize", { "persist": false }],
      "cmd-0": ["zed::ResetBufferFontSize", { "persist": false }],
-      "cmd-,": "zed::OpenSettings",
+      "cmd-,": "zed::OpenSettingsEditor",
+      "cmd-alt-,": "zed::OpenSettings",
      "cmd-q": "zed::Quit",
      "cmd-h": "zed::Hide",
      "alt-cmd-h": "zed::HideOthers",
@@ -289,7 +290,7 @@
      "alt-enter": "agent::ContinueWithBurnMode",
      "cmd-y": "agent::AllowOnce",
      "cmd-alt-y": "agent::AllowAlways",
-      "cmd-d": "agent::RejectOnce"
+      "cmd-alt-z": "agent::RejectOnce"
    }
  },
  {
@@ -581,15 +582,15 @@
      "cmd-k cmd-l": "editor::ToggleFold",
      "cmd-k cmd-[": "editor::FoldRecursive",
      "cmd-k cmd-]": "editor::UnfoldRecursive",
-      "cmd-k cmd-1": ["editor::FoldAtLevel", 1],
-      "cmd-k cmd-2": ["editor::FoldAtLevel", 2],
-      "cmd-k cmd-3": ["editor::FoldAtLevel", 3],
-      "cmd-k cmd-4": ["editor::FoldAtLevel", 4],
-      "cmd-k cmd-5": ["editor::FoldAtLevel", 5],
-      "cmd-k cmd-6": ["editor::FoldAtLevel", 6],
-      "cmd-k cmd-7": ["editor::FoldAtLevel", 7],
-      "cmd-k cmd-8": ["editor::FoldAtLevel", 8],
-      "cmd-k cmd-9": ["editor::FoldAtLevel", 9],
+      "cmd-k cmd-1": "editor::FoldAtLevel_1",
+      "cmd-k cmd-2": "editor::FoldAtLevel_2",
+      "cmd-k cmd-3": "editor::FoldAtLevel_3",
+      "cmd-k cmd-4": "editor::FoldAtLevel_4",
+      "cmd-k cmd-5": "editor::FoldAtLevel_5",
+      "cmd-k cmd-6": "editor::FoldAtLevel_6",
+      "cmd-k cmd-7": "editor::FoldAtLevel_7",
+      "cmd-k cmd-8": "editor::FoldAtLevel_8",
+      "cmd-k cmd-9": "editor::FoldAtLevel_9",
      "cmd-k cmd-0": "editor::FoldAll",
      "cmd-k cmd-j": "editor::UnfoldAll",
      // Using `ctrl-space` / `ctrl-shift-space` in Zed requires disabling the macOS global shortcut.
@@ -1333,10 +1334,7 @@
    "context": "Onboarding",
    "use_key_equivalents": true,
    "bindings": {
-      "cmd-1": "onboarding::ActivateBasicsPage",
-      "cmd-2": "onboarding::ActivateEditingPage",
-      "cmd-3": "onboarding::ActivateAISetupPage",
-      "cmd-escape": "onboarding::Finish",
+      "cmd-enter": "onboarding::Finish",
      "alt-tab": "onboarding::SignIn",
      "alt-shift-a": "onboarding::OpenAccount"
    }
@@ -1347,5 +1345,41 @@
    "bindings": {
      "ctrl-shift-enter": "workspace::OpenWithSystem"
    }
+  },
+  {
+    "context": "SettingsWindow",
+    "use_key_equivalents": true,
+    "bindings": {
+      "cmd-w": "workspace::CloseWindow",
+      "escape": "workspace::CloseWindow",
+      "cmd-m": "settings_editor::Minimize",
+      "cmd-f": "search::FocusSearch",
+      "cmd-shift-e": "settings_editor::ToggleFocusNav",
+      // todo(settings_ui): cut this down based on the max files and overflow UI
+      "ctrl-1": ["settings_editor::FocusFile", 0],
+      "ctrl-2": ["settings_editor::FocusFile", 1],
+      "ctrl-3": ["settings_editor::FocusFile", 2],
+      "ctrl-4": ["settings_editor::FocusFile", 3],
+      "ctrl-5": ["settings_editor::FocusFile", 4],
+      "ctrl-6": ["settings_editor::FocusFile", 5],
+      "ctrl-7": ["settings_editor::FocusFile", 6],
+      "ctrl-8": ["settings_editor::FocusFile", 7],
+      "ctrl-9": ["settings_editor::FocusFile", 8],
+      "ctrl-0": ["settings_editor::FocusFile", 9],
+      "cmd-{": "settings_editor::FocusPreviousFile",
+      "cmd-}": "settings_editor::FocusNextFile"
+    }
+  },
+  {
+    "context": "SettingsWindow > NavigationMenu",
+    "use_key_equivalents": true,
+    "bindings": {
+      "right": "settings_editor::ExpandNavEntry",
+      "left": "settings_editor::CollapseNavEntry",
+      "pageup": "settings_editor::FocusPreviousRootNavEntry",
+      "pagedown": "settings_editor::FocusNextRootNavEntry",
+      "home": "settings_editor::FocusFirstNavEntry",
+      "end": "settings_editor::FocusLastNavEntry"
+    }
  }
 ]
--- a/assets/keymaps/default-windows.json
+++ b/assets/keymaps/default-windows.json
@@ -29,7 +29,8 @@
      "ctrl-shift-=": ["zed::IncreaseBufferFontSize", { "persist": false }],
      "ctrl--": ["zed::DecreaseBufferFontSize", { "persist": false }],
      "ctrl-0": ["zed::ResetBufferFontSize", { "persist": false }],
-      "ctrl-,": "zed::OpenSettings",
+      "ctrl-,": "zed::OpenSettingsEditor",
+      "ctrl-alt-,": "zed::OpenSettings",
      "ctrl-q": "zed::Quit",
      "f4": "debugger::Start",
      "shift-f5": "debugger::Stop",
@@ -251,7 +252,7 @@
      "alt-enter": "agent::ContinueWithBurnMode",
      "ctrl-y": "agent::AllowOnce",
      "ctrl-alt-y": "agent::AllowAlways",
-      "ctrl-d": "agent::RejectOnce"
+      "ctrl-alt-z": "agent::RejectOnce"
    }
  },
  {
@@ -345,7 +346,7 @@
    }
  },
  {
-    "context": "AcpThread > Editor",
+    "context": "AcpThread > Editor && !use_modifier_to_send",
    "use_key_equivalents": true,
    "bindings": {
      "enter": "agent::Chat",
@@ -355,6 +356,17 @@
      "shift-tab": "agent::CycleModeSelector"
    }
  },
+  {
+    "context": "AcpThread > Editor && use_modifier_to_send",
+    "use_key_equivalents": true,
+    "bindings": {
+      "ctrl-enter": "agent::Chat",
+      "ctrl-shift-r": "agent::OpenAgentDiff",
+      "ctrl-shift-y": "agent::KeepAll",
+      "ctrl-shift-n": "agent::RejectAll",
+      "shift-tab": "agent::CycleModeSelector"
+    }
+  },
  {
    "context": "ThreadHistory",
    "use_key_equivalents": true,
@@ -367,7 +379,8 @@
    "use_key_equivalents": true,
    "bindings": {
      "ctrl-n": "rules_library::NewRule",
-      "ctrl-shift-s": "rules_library::ToggleDefaultRule"
+      "ctrl-shift-s": "rules_library::ToggleDefaultRule",
+      "ctrl-w": "workspace::CloseWindow"
    }
  },
  {
@@ -523,15 +536,15 @@
      "ctrl-k ctrl-l": "editor::ToggleFold",
      "ctrl-k ctrl-[": "editor::FoldRecursive",
      "ctrl-k ctrl-]": "editor::UnfoldRecursive",
-      "ctrl-k ctrl-1": ["editor::FoldAtLevel", 1],
-      "ctrl-k ctrl-2": ["editor::FoldAtLevel", 2],
-      "ctrl-k ctrl-3": ["editor::FoldAtLevel", 3],
-      "ctrl-k ctrl-4": ["editor::FoldAtLevel", 4],
-      "ctrl-k ctrl-5": ["editor::FoldAtLevel", 5],
-      "ctrl-k ctrl-6": ["editor::FoldAtLevel", 6],
-      "ctrl-k ctrl-7": ["editor::FoldAtLevel", 7],
-      "ctrl-k ctrl-8": ["editor::FoldAtLevel", 8],
-      "ctrl-k ctrl-9": ["editor::FoldAtLevel", 9],
+      "ctrl-k ctrl-1": "editor::FoldAtLevel_1",
+      "ctrl-k ctrl-2": "editor::FoldAtLevel_2",
+      "ctrl-k ctrl-3": "editor::FoldAtLevel_3",
+      "ctrl-k ctrl-4": "editor::FoldAtLevel_4",
+      "ctrl-k ctrl-5": "editor::FoldAtLevel_5",
+      "ctrl-k ctrl-6": "editor::FoldAtLevel_6",
+      "ctrl-k ctrl-7": "editor::FoldAtLevel_7",
+      "ctrl-k ctrl-8": "editor::FoldAtLevel_8",
+      "ctrl-k ctrl-9": "editor::FoldAtLevel_9",
      "ctrl-k ctrl-0": "editor::FoldAll",
      "ctrl-k ctrl-j": "editor::UnfoldAll",
      "ctrl-space": "editor::ShowCompletions",
@@ -1244,12 +1257,45 @@
    "context": "Onboarding",
    "use_key_equivalents": true,
    "bindings": {
-      "ctrl-1": "onboarding::ActivateBasicsPage",
-      "ctrl-2": "onboarding::ActivateEditingPage",
-      "ctrl-3": "onboarding::ActivateAISetupPage",
      "ctrl-enter": "onboarding::Finish",
      "alt-shift-l": "onboarding::SignIn",
      "shift-alt-a": "onboarding::OpenAccount"
    }
+  },
+  {
+    "context": "SettingsWindow",
+    "use_key_equivalents": true,
+    "bindings": {
+      "ctrl-w": "workspace::CloseWindow",
+      "escape": "workspace::CloseWindow",
+      "ctrl-m": "settings_editor::Minimize",
+      "ctrl-f": "search::FocusSearch",
+      "ctrl-shift-e": "settings_editor::ToggleFocusNav",
+      // todo(settings_ui): cut this down based on the max files and overflow UI
+      "ctrl-1": ["settings_editor::FocusFile", 0],
+      "ctrl-2": ["settings_editor::FocusFile", 1],
+      "ctrl-3": ["settings_editor::FocusFile", 2],
+      "ctrl-4": ["settings_editor::FocusFile", 3],
+      "ctrl-5": ["settings_editor::FocusFile", 4],
+      "ctrl-6": ["settings_editor::FocusFile", 5],
+      "ctrl-7": ["settings_editor::FocusFile", 6],
+      "ctrl-8": ["settings_editor::FocusFile", 7],
+      "ctrl-9": ["settings_editor::FocusFile", 8],
+      "ctrl-0": ["settings_editor::FocusFile", 9],
+      "ctrl-pageup": "settings_editor::FocusPreviousFile",
+      "ctrl-pagedown": "settings_editor::FocusNextFile"
+    }
+  },
+  {
+    "context": "SettingsWindow > NavigationMenu",
+    "use_key_equivalents": true,
+    "bindings": {
+      "right": "settings_editor::ExpandNavEntry",
+      "left": "settings_editor::CollapseNavEntry",
+      "pageup": "settings_editor::FocusPreviousRootNavEntry",
+      "pagedown": "settings_editor::FocusNextRootNavEntry",
+      "home": "settings_editor::FocusFirstNavEntry",
+      "end": "settings_editor::FocusLastNavEntry"
+    }
  }
 ]
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -240,6 +240,7 @@
      "delete": "vim::DeleteRight",
      "g shift-j": "vim::JoinLinesNoWhitespace",
      "y": "vim::PushYank",
+      "shift-y": "vim::YankLine",
      "x": "vim::DeleteRight",
      "shift-x": "vim::DeleteLeft",
      "ctrl-a": "vim::Increment",
@@ -579,18 +580,18 @@
      // "q": "vim::AnyQuotes",
      "q": "vim::MiniQuotes",
      "|": "vim::VerticalBars",
-      "(": "vim::Parentheses",
+      "(": ["vim::Parentheses", { "opening": true }],
      ")": "vim::Parentheses",
      "b": "vim::Parentheses",
      // "b": "vim::AnyBrackets",
      // "b": "vim::MiniBrackets",
-      "[": "vim::SquareBrackets",
+      "[": ["vim::SquareBrackets", { "opening": true }],
      "]": "vim::SquareBrackets",
      "r": "vim::SquareBrackets",
-      "{": "vim::CurlyBrackets",
+      "{": ["vim::CurlyBrackets", { "opening": true }],
      "}": "vim::CurlyBrackets",
      "shift-b": "vim::CurlyBrackets",
-      "<": "vim::AngleBrackets",
+      "<": ["vim::AngleBrackets", { "opening": true }],
      ">": "vim::AngleBrackets",
      "a": "vim::Argument",
      "i": "vim::IndentObj",
@@ -883,10 +884,12 @@
      "/": "project_panel::NewSearchInDirectory",
      "d": "project_panel::NewDirectory",
      "enter": "project_panel::OpenPermanent",
-      "escape": "project_panel::ToggleFocus",
+      "escape": "vim::ToggleProjectPanelFocus",
      "h": "project_panel::CollapseSelectedEntry",
-      "j": "menu::SelectNext",
-      "k": "menu::SelectPrevious",
+      "j": "vim::MenuSelectNext",
+      "k": "vim::MenuSelectPrevious",
+      "down": "vim::MenuSelectNext",
+      "up": "vim::MenuSelectPrevious",
      "l": "project_panel::ExpandSelectedEntry",
      "shift-d": "project_panel::Delete",
      "shift-r": "project_panel::Rename",
@@ -905,7 +908,22 @@
      "{": "project_panel::SelectPrevDirectory",
      "shift-g": "menu::SelectLast",
      "g g": "menu::SelectFirst",
-      "-": "project_panel::SelectParent"
+      "-": "project_panel::SelectParent",
+      "ctrl-u": "project_panel::ScrollUp",
+      "ctrl-d": "project_panel::ScrollDown",
+      "z t": "project_panel::ScrollCursorTop",
+      "z z": "project_panel::ScrollCursorCenter",
+      "z b": "project_panel::ScrollCursorBottom",
+      "0": ["vim::Number", 0],
+      "1": ["vim::Number", 1],
+      "2": ["vim::Number", 2],
+      "3": ["vim::Number", 3],
+      "4": ["vim::Number", 4],
+      "5": ["vim::Number", 5],
+      "6": ["vim::Number", 6],
+      "7": ["vim::Number", 7],
+      "8": ["vim::Number", 8],
+      "9": ["vim::Number", 9]
    }
  },
  {
--- a/assets/prompts/content_prompt.hbs
+++ b/assets/prompts/content_prompt.hbs
@@ -29,7 +29,9 @@ Generate {{content_type}} based on the following prompt:

 Match the indentation in the original file in the inserted {{content_type}}, don't include any indentation on blank lines.

-Immediately start with the following format with no remarks:
+Return ONLY the {{content_type}} to insert. Do NOT include any XML tags like <document>, <insert_here>, or any surrounding markup from the input.
+
+Respond with a code block containing the {{content_type}} to insert. Replace \{{INSERTED_CODE}} with your actual {{content_type}}:

 ```
 \{{INSERTED_CODE}}
@@ -66,7 +68,9 @@ Only make changes that are necessary to fulfill the prompt, leave everything els

 Start at the indentation level in the original file in the rewritten {{content_type}}. Don't stop until you've rewritten the entire section, even if you have no more changes to make, always write out the whole section with no unnecessary elisions.

-Immediately start with the following format with no remarks:
+Return ONLY the rewritten {{content_type}}. Do NOT include any XML tags like <document>, <rewrite_this>, or any surrounding markup from the input.
+
+Respond with a code block containing the rewritten {{content_type}}. Replace \{{REWRITTEN_CODE}} with your actual rewritten {{content_type}}:

 ```
 \{{REWRITTEN_CODE}}
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -1,5 +1,7 @@
 {
-  "project_name": null,
+  /// The displayed name of this project. If not set or empty, the root directory name
+  /// will be displayed.
+  "project_name": "",
  // The name of the Zed theme to use for the UI.
  //
  // `mode` is one of:
@@ -72,8 +74,10 @@
  "ui_font_weight": 400,
  // The default font size for text in the UI
  "ui_font_size": 16,
-  // The default font size for text in the agent panel. Falls back to the UI font size if unset.
-  "agent_font_size": null,
+  // The default font size for agent responses in the agent panel. Falls back to the UI font size if unset.
+  "agent_ui_font_size": null,
+  // The default font size for user messages in the agent panel.
+  "agent_buffer_font_size": 12,
  // How much to fade out unused code.
  "unnecessary_code_fade": 0.3,
  // Active pane styling settings.
@@ -1227,6 +1231,10 @@
    // 2. Hide the gutter
    //      "git_gutter": "hide"
    "git_gutter": "tracked_files",
+    /// Sets the debounce threshold (in milliseconds) after which changes are reflected in the git gutter.
+    ///
+    /// Default: 0
+    "gutter_debounce": 0,
    // Control whether the git blame information is shown inline,
    // in the currently focused line.
    "inline_blame": {
@@ -1242,6 +1250,9 @@
      // The minimum column number to show the inline blame information at
      "min_column": 0
    },
+    "blame": {
+      "show_avatar": true
+    },
    // Control which information is shown in the branch picker.
    "branch_picker": {
      "show_author_name": true
@@ -1300,15 +1311,18 @@
    //   "proxy": "",
    //   "proxy_no_verify": false
    // },
-    // Whether edit predictions are enabled when editing text threads.
-    // This setting has no effect if globally disabled.
-    "enabled_in_text_threads": true,
-
    "copilot": {
      "enterprise_uri": null,
      "proxy": null,
      "proxy_no_verify": null
-    }
+    },
+    "codestral": {
+      "model": null,
+      "max_tokens": null
+    },
+    // Whether edit predictions are enabled when editing text threads.
+    // This setting has no effect if globally disabled.
+    "enabled_in_text_threads": true
  },
  // Settings specific to journaling
  "journal": {
@@ -1322,6 +1336,8 @@
  },
  // Status bar-related settings.
  "status_bar": {
+    // Whether to show the status bar.
+    "experimental.show": true,
    // Whether to show the active language button in the status bar.
    "active_language_button": true,
    // Whether to show the cursor position button in the status bar.
@@ -1388,8 +1404,8 @@
    //  4. A box drawn around the following character
    //     "hollow"
    //
-    // Default: not set, defaults to "block"
-    "cursor_shape": null,
+    // Default: "block"
+    "cursor_shape": "block",
    // Set whether Alternate Scroll mode (code: ?1007) is active by default.
    // Alternate Scroll mode converts mouse scroll events into up / down key
    // presses when in the alternate screen (e.g. when running applications
@@ -1411,8 +1427,8 @@
    // Whether or not selecting text in the terminal will automatically
    // copy to the system clipboard.
    "copy_on_select": false,
-    // Whether to keep the text selection after copying it to the clipboard
-    "keep_selection_on_copy": false,
+    // Whether to keep the text selection after copying it to the clipboard.
+    "keep_selection_on_copy": true,
    // Whether to show the terminal button in the status bar
    "button": true,
    // Any key-value pairs added to this list will be added to the terminal's
@@ -1557,6 +1573,14 @@
  "auto_install_extensions": {
    "html": true
  },
+  // The capabilities granted to extensions.
+  //
+  // This list can be customized to restrict what extensions are able to do.
+  "granted_extension_capabilities": [
+    { "kind": "process:exec", "command": "*", "args": ["**"] },
+    { "kind": "download_file", "host": "*", "path": ["**"] },
+    { "kind": "npm:install", "package": "*" }
+  ],
  // Controls how completions are processed for this language.
  "completions": {
    // Controls how words are completed.
@@ -1855,21 +1879,19 @@
  // Allows to enable/disable formatting with Prettier
  // and configure default Prettier, used when no project-level Prettier installation is found.
  "prettier": {
-    // // Whether to consider prettier formatter or not when attempting to format a file.
-    "allowed": false
-    //
-    // // Use regular Prettier json configuration.
-    // // If Prettier is allowed, Zed will use this for its Prettier instance for any applicable file, if
-    // // the project has no other Prettier installed.
-    // "plugins": [],
-    //
-    // // Use regular Prettier json configuration.
-    // // If Prettier is allowed, Zed will use this for its Prettier instance for any applicable file, if
-    // // the project has no other Prettier installed.
+    // Enables or disables formatting with Prettier for any given language.
+    "allowed": false,
+    // Forces Prettier integration to use a specific parser name when formatting files with the language.
+    "plugins": [],
+    // Default Prettier options, in the format as in package.json section for Prettier.
+    // If project installs Prettier via its package.json, these options will be ignored.
    // "trailingComma": "es5",
    // "tabWidth": 4,
    // "semi": false,
    // "singleQuote": true
+    // Forces Prettier integration to use a specific parser name when formatting files with the language
+    // when set to a non-empty string.
+    "parser": ""
  },
  // Settings for auto-closing of JSX tags.
  "jsx_tag_auto_close": {
@@ -2019,7 +2041,7 @@
  // Examples:
  // "profiles": {
  //   "Presenting": {
-  //     "agent_font_size": 20.0,
+  //     "agent_ui_font_size": 20.0,
  //     "buffer_font_size": 20.0,
  //     "theme": "One Light",
  //     "ui_font_size": 20.0
--- a/assets/sounds/guest_joined_call.wav
+++ b/assets/sounds/guest_joined_call.wav
--- a/assets/themes/ayu/ayu.json
+++ b/assets/themes/ayu/ayu.json
@@ -192,7 +192,7 @@
            "font_weight": null
          },
          "comment": {
-            "color": "#abb5be8c",
+            "color": "#5c6773ff",
            "font_style": null,
            "font_weight": null
          },
@@ -239,7 +239,7 @@
          "hint": {
            "color": "#628b80ff",
            "font_style": null,
-            "font_weight": 700
+            "font_weight": null
          },
          "keyword": {
            "color": "#ff8f3fff",
@@ -583,7 +583,7 @@
            "font_weight": null
          },
          "comment": {
-            "color": "#787b8099",
+            "color": "#abb0b6ff",
            "font_style": null,
            "font_weight": null
          },
@@ -630,7 +630,7 @@
          "hint": {
            "color": "#8ca7c2ff",
            "font_style": null,
-            "font_weight": 700
+            "font_weight": null
          },
          "keyword": {
            "color": "#fa8d3eff",
@@ -974,7 +974,7 @@
            "font_weight": null
          },
          "comment": {
-            "color": "#b8cfe680",
+            "color": "#5c6773ff",
            "font_style": null,
            "font_weight": null
          },
@@ -1021,7 +1021,7 @@
          "hint": {
            "color": "#7399a3ff",
            "font_style": null,
-            "font_weight": 700
+            "font_weight": null
          },
          "keyword": {
            "color": "#ffad65ff",
--- a/assets/themes/gruvbox/gruvbox.json
+++ b/assets/themes/gruvbox/gruvbox.json
@@ -248,7 +248,7 @@
          "hint": {
            "color": "#8c957dff",
            "font_style": null,
-            "font_weight": 700
+            "font_weight": null
          },
          "keyword": {
            "color": "#fb4833ff",
@@ -653,7 +653,7 @@
          "hint": {
            "color": "#8c957dff",
            "font_style": null,
-            "font_weight": 700
+            "font_weight": null
          },
          "keyword": {
            "color": "#fb4833ff",
@@ -1058,7 +1058,7 @@
          "hint": {
            "color": "#8c957dff",
            "font_style": null,
-            "font_weight": 700
+            "font_weight": null
          },
          "keyword": {
            "color": "#fb4833ff",
@@ -1463,7 +1463,7 @@
          "hint": {
            "color": "#677562ff",
            "font_style": null,
-            "font_weight": 700
+            "font_weight": null
          },
          "keyword": {
            "color": "#9d0006ff",
@@ -1868,7 +1868,7 @@
          "hint": {
            "color": "#677562ff",
            "font_style": null,
-            "font_weight": 700
+            "font_weight": null
          },
          "keyword": {
            "color": "#9d0006ff",
@@ -2273,7 +2273,7 @@
          "hint": {
            "color": "#677562ff",
            "font_style": null,
-            "font_weight": 700
+            "font_weight": null
          },
          "keyword": {
            "color": "#9d0006ff",
--- a/assets/themes/one/one.json
+++ b/assets/themes/one/one.json
@@ -244,7 +244,7 @@
          "hint": {
            "color": "#788ca6ff",
            "font_style": null,
-            "font_weight": 700
+            "font_weight": null
          },
          "keyword": {
            "color": "#b477cfff",
@@ -643,7 +643,7 @@
          "hint": {
            "color": "#7274a7ff",
            "font_style": null,
-            "font_weight": 700
+            "font_weight": null
          },
          "keyword": {
            "color": "#a449abff",
--- a/crates/acp_thread/src/acp_thread.rs
+++ b/crates/acp_thread/src/acp_thread.rs
@@ -3,6 +3,7 @@ mod diff;
 mod mention;
 mod terminal;

+use ::terminal::terminal_settings::TerminalSettings;
 use agent_settings::AgentSettings;
 use collections::HashSet;
 pub use connection::*;
@@ -11,7 +12,7 @@ use language::language_settings::FormatOnSave;
 pub use mention::*;
 use project::lsp_store::{FormatTrigger, LspFormatTarget};
 use serde::{Deserialize, Serialize};
-use settings::Settings as _;
+use settings::{Settings as _, SettingsLocation};
 use task::{Shell, ShellBuilder};
 pub use terminal::*;

@@ -34,7 +35,7 @@ use std::rc::Rc;
 use std::time::{Duration, Instant};
 use std::{fmt::Display, mem, path::PathBuf, sync::Arc};
 use ui::App;
-use util::{ResultExt, get_default_system_shell};
+use util::{ResultExt, get_default_system_shell_preferring_bash};
 use uuid::Uuid;

 #[derive(Debug)]
@@ -573,7 +574,7 @@ impl ToolCallContent {
            ))),
            acp::ToolCallContent::Diff { diff } => Ok(Self::Diff(cx.new(|cx| {
                Diff::finalized(
-                    diff.path.to_string_lossy().to_string(),
+                    diff.path.to_string_lossy().into_owned(),
                    diff.old_text,
                    diff.new_text,
                    language_registry,
@@ -787,6 +788,8 @@ pub struct AcpThread {
    prompt_capabilities: acp::PromptCapabilities,
    _observe_prompt_capabilities: Task<anyhow::Result<()>>,
    terminals: HashMap<acp::TerminalId, Entity<Terminal>>,
+    pending_terminal_output: HashMap<acp::TerminalId, Vec<Vec<u8>>>,
+    pending_terminal_exit: HashMap<acp::TerminalId, acp::TerminalExitStatus>,
 }

 #[derive(Debug)]
@@ -809,6 +812,126 @@ pub enum AcpThreadEvent {

 impl EventEmitter<AcpThreadEvent> for AcpThread {}

+#[derive(Debug, Clone)]
+pub enum TerminalProviderEvent {
+    Created {
+        terminal_id: acp::TerminalId,
+        label: String,
+        cwd: Option<PathBuf>,
+        output_byte_limit: Option<u64>,
+        terminal: Entity<::terminal::Terminal>,
+    },
+    Output {
+        terminal_id: acp::TerminalId,
+        data: Vec<u8>,
+    },
+    TitleChanged {
+        terminal_id: acp::TerminalId,
+        title: String,
+    },
+    Exit {
+        terminal_id: acp::TerminalId,
+        status: acp::TerminalExitStatus,
+    },
+}
+
+#[derive(Debug, Clone)]
+pub enum TerminalProviderCommand {
+    WriteInput {
+        terminal_id: acp::TerminalId,
+        bytes: Vec<u8>,
+    },
+    Resize {
+        terminal_id: acp::TerminalId,
+        cols: u16,
+        rows: u16,
+    },
+    Close {
+        terminal_id: acp::TerminalId,
+    },
+}
+
+impl AcpThread {
+    pub fn on_terminal_provider_event(
+        &mut self,
+        event: TerminalProviderEvent,
+        cx: &mut Context<Self>,
+    ) {
+        match event {
+            TerminalProviderEvent::Created {
+                terminal_id,
+                label,
+                cwd,
+                output_byte_limit,
+                terminal,
+            } => {
+                let entity = self.register_terminal_created(
+                    terminal_id.clone(),
+                    label,
+                    cwd,
+                    output_byte_limit,
+                    terminal,
+                    cx,
+                );
+
+                if let Some(mut chunks) = self.pending_terminal_output.remove(&terminal_id) {
+                    for data in chunks.drain(..) {
+                        entity.update(cx, |term, cx| {
+                            term.inner().update(cx, |inner, cx| {
+                                inner.write_output(&data, cx);
+                            })
+                        });
+                    }
+                }
+
+                if let Some(_status) = self.pending_terminal_exit.remove(&terminal_id) {
+                    entity.update(cx, |_term, cx| {
+                        cx.notify();
+                    });
+                }
+
+                cx.notify();
+            }
+            TerminalProviderEvent::Output { terminal_id, data } => {
+                if let Some(entity) = self.terminals.get(&terminal_id) {
+                    entity.update(cx, |term, cx| {
+                        term.inner().update(cx, |inner, cx| {
+                            inner.write_output(&data, cx);
+                        })
+                    });
+                } else {
+                    self.pending_terminal_output
+                        .entry(terminal_id)
+                        .or_default()
+                        .push(data);
+                }
+            }
+            TerminalProviderEvent::TitleChanged { terminal_id, title } => {
+                if let Some(entity) = self.terminals.get(&terminal_id) {
+                    entity.update(cx, |term, cx| {
+                        term.inner().update(cx, |inner, cx| {
+                            inner.breadcrumb_text = title;
+                            cx.emit(::terminal::Event::BreadcrumbsChanged);
+                        })
+                    });
+                }
+            }
+            TerminalProviderEvent::Exit {
+                terminal_id,
+                status,
+            } => {
+                if let Some(entity) = self.terminals.get(&terminal_id) {
+                    entity.update(cx, |_term, cx| {
+                        cx.notify();
+                    });
+                } else {
+                    self.pending_terminal_exit.insert(terminal_id, status);
+                }
+            }
+        }
+    }
+}
+
 #[derive(PartialEq, Eq, Debug)]
 pub enum ThreadStatus {
    Idle,
@@ -886,6 +1009,8 @@ impl AcpThread {
            prompt_capabilities,
            _observe_prompt_capabilities: task,
            terminals: HashMap::default(),
+            pending_terminal_output: HashMap::default(),
+            pending_terminal_exit: HashMap::default(),
        }
    }

@@ -1961,16 +2086,24 @@ impl AcpThread {
    ) -> Task<Result<Entity<Terminal>>> {
        let env = match &cwd {
            Some(dir) => self.project.update(cx, |project, cx| {
-                project.directory_environment(dir.as_path().into(), cx)
+                let worktree = project.find_worktree(dir.as_path(), cx);
+                let shell = TerminalSettings::get(
+                    worktree.as_ref().map(|(worktree, path)| SettingsLocation {
+                        worktree_id: worktree.read(cx).id(),
+                        path: &path,
+                    }),
+                    cx,
+                )
+                .shell
+                .clone();
+                project.directory_environment(&shell, dir.as_path().into(), cx)
            }),
            None => Task::ready(None).shared(),
        };
-
        let env = cx.spawn(async move |_, _| {
            let mut env = env.await.unwrap_or_default();
-            if cfg!(unix) {
-                env.insert("PAGER".into(), "cat".into());
-            }
+            // Disables paging for `git` and hopefully other commands
+            env.insert("PAGER".into(), "".into());
            for var in extra_env {
                env.insert(var.name, var.value);
            }
@@ -1985,24 +2118,22 @@ impl AcpThread {
            let terminal_id = terminal_id.clone();
            async move |_this, cx| {
                let env = env.await;
-                let (command, args) = ShellBuilder::new(
-                    project
-                        .update(cx, |project, cx| {
-                            project
-                                .remote_client()
-                                .and_then(|r| r.read(cx).default_system_shell())
-                        })?
-                        .as_deref(),
-                    &Shell::Program(get_default_system_shell()),
-                )
-                .redirect_stdin_to_dev_null()
-                .build(Some(command), &args);
+                let shell = project
+                    .update(cx, |project, cx| {
+                        project
+                            .remote_client()
+                            .and_then(|r| r.read(cx).default_system_shell())
+                    })?
+                    .unwrap_or_else(|| get_default_system_shell_preferring_bash());
+                let (task_command, task_args) = ShellBuilder::new(&Shell::Program(shell))
+                    .redirect_stdin_to_dev_null()
+                    .build(Some(command.clone()), &args);
                let terminal = project
                    .update(cx, |project, cx| {
                        project.create_terminal_task(
                            task::SpawnInTerminal {
-                                command: Some(command.clone()),
-                                args: args.clone(),
+                                command: Some(task_command),
+                                args: task_args,
                                cwd: cwd.clone(),
                                env,
                                ..Default::default()
@@ -2079,6 +2210,32 @@ impl AcpThread {
    pub fn emit_load_error(&mut self, error: LoadError, cx: &mut Context<Self>) {
        cx.emit(AcpThreadEvent::LoadError(error));
    }
+
+    pub fn register_terminal_created(
+        &mut self,
+        terminal_id: acp::TerminalId,
+        command_label: String,
+        working_dir: Option<PathBuf>,
+        output_byte_limit: Option<u64>,
+        terminal: Entity<::terminal::Terminal>,
+        cx: &mut Context<Self>,
+    ) -> Entity<Terminal> {
+        let language_registry = self.project.read(cx).languages().clone();
+
+        let entity = cx.new(|cx| {
+            Terminal::new(
+                terminal_id.clone(),
+                &command_label,
+                working_dir.clone(),
+                output_byte_limit.map(|l| l as usize),
+                terminal,
+                language_registry,
+                cx,
+            )
+        });
+        self.terminals.insert(terminal_id.clone(), entity.clone());
+        entity
+    }
 }

 fn markdown_for_raw_output(
@@ -2155,6 +2312,145 @@ mod tests {
        });
    }

+    #[gpui::test]
+    async fn test_terminal_output_buffered_before_created_renders(cx: &mut gpui::TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        let project = Project::test(fs, [], cx).await;
+        let connection = Rc::new(FakeAgentConnection::new());
+        let thread = cx
+            .update(|cx| connection.new_thread(project, std::path::Path::new(path!("/test")), cx))
+            .await
+            .unwrap();
+
+        let terminal_id = acp::TerminalId(uuid::Uuid::new_v4().to_string().into());
+
+        // Send Output BEFORE Created - should be buffered by acp_thread
+        thread.update(cx, |thread, cx| {
+            thread.on_terminal_provider_event(
+                TerminalProviderEvent::Output {
+                    terminal_id: terminal_id.clone(),
+                    data: b"hello buffered".to_vec(),
+                },
+                cx,
+            );
+        });
+
+        // Create a display-only terminal and then send Created
+        let lower = cx.new(|cx| {
+            let builder = ::terminal::TerminalBuilder::new_display_only(
+                ::terminal::terminal_settings::CursorShape::default(),
+                ::terminal::terminal_settings::AlternateScroll::On,
+                None,
+                0,
+            )
+            .unwrap();
+            builder.subscribe(cx)
+        });
+
+        thread.update(cx, |thread, cx| {
+            thread.on_terminal_provider_event(
+                TerminalProviderEvent::Created {
+                    terminal_id: terminal_id.clone(),
+                    label: "Buffered Test".to_string(),
+                    cwd: None,
+                    output_byte_limit: None,
+                    terminal: lower.clone(),
+                },
+                cx,
+            );
+        });
+
+        // After Created, buffered Output should have been flushed into the renderer
+        let content = thread.read_with(cx, |thread, cx| {
+            let term = thread.terminal(terminal_id.clone()).unwrap();
+            term.read_with(cx, |t, cx| t.inner().read(cx).get_content())
+        });
+
+        assert!(
+            content.contains("hello buffered"),
+            "expected buffered output to render, got: {content}"
+        );
+    }
+
+    #[gpui::test]
+    async fn test_terminal_output_and_exit_buffered_before_created(cx: &mut gpui::TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        let project = Project::test(fs, [], cx).await;
+        let connection = Rc::new(FakeAgentConnection::new());
+        let thread = cx
+            .update(|cx| connection.new_thread(project, std::path::Path::new(path!("/test")), cx))
+            .await
+            .unwrap();
+
+        let terminal_id = acp::TerminalId(uuid::Uuid::new_v4().to_string().into());
+
+        // Send Output BEFORE Created
+        thread.update(cx, |thread, cx| {
+            thread.on_terminal_provider_event(
+                TerminalProviderEvent::Output {
+                    terminal_id: terminal_id.clone(),
+                    data: b"pre-exit data".to_vec(),
+                },
+                cx,
+            );
+        });
+
+        // Send Exit BEFORE Created
+        thread.update(cx, |thread, cx| {
+            thread.on_terminal_provider_event(
+                TerminalProviderEvent::Exit {
+                    terminal_id: terminal_id.clone(),
+                    status: acp::TerminalExitStatus {
+                        exit_code: Some(0),
+                        signal: None,
+                        meta: None,
+                    },
+                },
+                cx,
+            );
+        });
+
+        // Now create a display-only lower-level terminal and send Created
+        let lower = cx.new(|cx| {
+            let builder = ::terminal::TerminalBuilder::new_display_only(
+                ::terminal::terminal_settings::CursorShape::default(),
+                ::terminal::terminal_settings::AlternateScroll::On,
+                None,
+                0,
+            )
+            .unwrap();
+            builder.subscribe(cx)
+        });
+
+        thread.update(cx, |thread, cx| {
+            thread.on_terminal_provider_event(
+                TerminalProviderEvent::Created {
+                    terminal_id: terminal_id.clone(),
+                    label: "Buffered Exit Test".to_string(),
+                    cwd: None,
+                    output_byte_limit: None,
+                    terminal: lower.clone(),
+                },
+                cx,
+            );
+        });
+
+        // Output should be present after Created (flushed from buffer)
+        let content = thread.read_with(cx, |thread, cx| {
+            let term = thread.terminal(terminal_id.clone()).unwrap();
+            term.read_with(cx, |t, cx| t.inner().read(cx).get_content())
+        });
+
+        assert!(
+            content.contains("pre-exit data"),
+            "expected pre-exit data to render, got: {content}"
+        );
+    }
+
    #[gpui::test]
    async fn test_push_user_content_block(cx: &mut gpui::TestAppContext) {
        init_test(cx);
--- a/crates/acp_thread/src/diff.rs
+++ b/crates/acp_thread/src/diff.rs
@@ -31,7 +31,7 @@ impl Diff {
            let buffer = new_buffer.clone();
            async move |_, cx| {
                let language = language_registry
-                    .language_for_file_path(Path::new(&path))
+                    .load_language_for_file_path(Path::new(&path))
                    .await
                    .log_err();

--- a/crates/agent/src/context.rs
+++ b/crates/agent/src/context.rs
@@ -187,7 +187,7 @@ impl FileContextHandle {
            log::error!("file context missing path");
            return Task::ready(None);
        };
-        let full_path = file.full_path(cx).to_string_lossy().to_string();
+        let full_path = file.full_path(cx).to_string_lossy().into_owned();
        let rope = buffer_ref.as_rope().clone();
        let buffer = self.buffer.clone();

@@ -283,7 +283,7 @@ impl DirectoryContextHandle {
        let descendants_future = future::join_all(file_paths.into_iter().map(|path| {
            let worktree_ref = worktree.read(cx);
            let worktree_id = worktree_ref.id();
-            let full_path = worktree_ref.full_path(&path).to_string_lossy().to_string();
+            let full_path = worktree_ref.full_path(&path).to_string_lossy().into_owned();

            let rel_path = path
                .strip_prefix(&directory_path)
@@ -403,7 +403,7 @@ impl SymbolContextHandle {
            log::error!("symbol context's file has no path");
            return Task::ready(None);
        };
-        let full_path = file.full_path(cx).to_string_lossy().to_string();
+        let full_path = file.full_path(cx).to_string_lossy().into_owned();
        let line_range = self.enclosing_range.to_point(&buffer_ref.snapshot());
        let text = self.text(cx);
        let buffer = self.buffer.clone();
@@ -476,7 +476,7 @@ impl SelectionContextHandle {
        let text = self.text(cx);
        let buffer = self.buffer.clone();
        let context = AgentContext::Selection(SelectionContext {
-            full_path: full_path.to_string_lossy().to_string(),
+            full_path: full_path.to_string_lossy().into_owned(),
            line_range: self.line_range(cx),
            text,
            handle: self,
--- a/crates/agent/src/context_store.rs
+++ b/crates/agent/src/context_store.rs
@@ -312,7 +312,7 @@ impl ContextStore {
                let item = image_item.read(cx);
                this.insert_image(
                    Some(item.project_path(cx)),
-                    Some(item.file.full_path(cx).to_string_lossy().to_string()),
+                    Some(item.file.full_path(cx).to_string_lossy().into_owned()),
                    item.image.clone(),
                    remove_if_exists,
                    cx,
--- a/crates/agent/src/history_store.rs
+++ b/crates/agent/src/history_store.rs
@@ -155,7 +155,7 @@ impl HistoryStore {
            .iter()
            .filter_map(|entry| match entry {
                HistoryEntryId::Context(path) => path.file_name().map(|file| {
-                    SerializedRecentOpen::ContextName(file.to_string_lossy().to_string())
+                    SerializedRecentOpen::ContextName(file.to_string_lossy().into_owned())
                }),
                HistoryEntryId::Thread(id) => Some(SerializedRecentOpen::Thread(id.to_string())),
            })
--- a/crates/agent/src/thread.rs
+++ b/crates/agent/src/thread.rs
@@ -1276,62 +1276,6 @@ impl Thread {
        );
    }

-    pub fn retry_last_completion(
-        &mut self,
-        window: Option<AnyWindowHandle>,
-        cx: &mut Context<Self>,
-    ) {
-        // Clear any existing error state
-        self.retry_state = None;
-
-        // Use the last error context if available, otherwise fall back to configured model
-        let (model, intent) = if let Some((model, intent)) = self.last_error_context.take() {
-            (model, intent)
-        } else if let Some(configured_model) = self.configured_model.as_ref() {
-            let model = configured_model.model.clone();
-            let intent = if self.has_pending_tool_uses() {
-                CompletionIntent::ToolResults
-            } else {
-                CompletionIntent::UserPrompt
-            };
-            (model, intent)
-        } else if let Some(configured_model) = self.get_or_init_configured_model(cx) {
-            let model = configured_model.model.clone();
-            let intent = if self.has_pending_tool_uses() {
-                CompletionIntent::ToolResults
-            } else {
-                CompletionIntent::UserPrompt
-            };
-            (model, intent)
-        } else {
-            return;
-        };
-
-        self.send_to_model(model, intent, window, cx);
-    }
-
-    pub fn enable_burn_mode_and_retry(
-        &mut self,
-        window: Option<AnyWindowHandle>,
-        cx: &mut Context<Self>,
-    ) {
-        self.completion_mode = CompletionMode::Burn;
-        cx.emit(ThreadEvent::ProfileChanged);
-        self.retry_last_completion(window, cx);
-    }
-
-    pub fn used_tools_since_last_user_message(&self) -> bool {
-        for message in self.messages.iter().rev() {
-            if self.tool_use.message_has_tool_results(message.id) {
-                return true;
-            } else if message.role == Role::User {
-                return false;
-            }
-        }
-
-        false
-    }
-
    pub fn to_completion_request(
        &self,
        model: Arc<dyn LanguageModel>,
@@ -2875,7 +2819,7 @@ impl Thread {
            // Get worktree path and snapshot
            let worktree_info = cx.update(|app_cx| {
                let worktree = worktree.read(app_cx);
-                let path = worktree.abs_path().to_string_lossy().to_string();
+                let path = worktree.abs_path().to_string_lossy().into_owned();
                let snapshot = worktree.snapshot();
                (path, snapshot)
            });
@@ -3276,7 +3220,6 @@ mod tests {
    use settings::{LanguageModelParameters, Settings, SettingsStore};
    use std::sync::Arc;
    use std::time::Duration;
-    use theme::ThemeSettings;
    use util::path;
    use workspace::Workspace;

@@ -5337,7 +5280,7 @@ fn main() {{
            thread_store::init(fs.clone(), cx);
            workspace::init_settings(cx);
            language_model::init_settings(cx);
-            ThemeSettings::register(cx);
+            theme::init(theme::LoadThemes::JustBase, cx);
            ToolRegistry::default_global(cx);
            assistant_tool::init(cx);

--- a/crates/agent/src/thread_store.rs
+++ b/crates/agent/src/thread_store.rs
@@ -38,7 +38,7 @@ use std::{
    cell::{Ref, RefCell},
    path::{Path, PathBuf},
    rc::Rc,
-    sync::{Arc, Mutex},
+    sync::{Arc, LazyLock, Mutex},
 };
 use util::{ResultExt as _, rel_path::RelPath};

@@ -74,17 +74,19 @@ impl Column for DataType {
    }
 }

-const RULES_FILE_NAMES: [&str; 9] = [
-    ".rules",
-    ".cursorrules",
-    ".windsurfrules",
-    ".clinerules",
-    ".github/copilot-instructions.md",
-    "CLAUDE.md",
-    "AGENT.md",
-    "AGENTS.md",
-    "GEMINI.md",
-];
+static RULES_FILE_NAMES: LazyLock<[&RelPath; 9]> = LazyLock::new(|| {
+    [
+        RelPath::unix(".rules").unwrap(),
+        RelPath::unix(".cursorrules").unwrap(),
+        RelPath::unix(".windsurfrules").unwrap(),
+        RelPath::unix(".clinerules").unwrap(),
+        RelPath::unix(".github/copilot-instructions.md").unwrap(),
+        RelPath::unix("CLAUDE.md").unwrap(),
+        RelPath::unix("AGENT.md").unwrap(),
+        RelPath::unix("AGENTS.md").unwrap(),
+        RelPath::unix("GEMINI.md").unwrap(),
+    ]
+});

 pub fn init(fs: Arc<dyn Fs>, cx: &mut App) {
    ThreadsDatabase::init(fs, cx);
@@ -232,11 +234,10 @@ impl ThreadStore {
                self.enqueue_system_prompt_reload();
            }
            project::Event::WorktreeUpdatedEntries(_, items) => {
-                if items.iter().any(|(path, _, _)| {
-                    RULES_FILE_NAMES
-                        .iter()
-                        .any(|name| path.as_ref() == RelPath::unix(name).unwrap())
-                }) {
+                if items
+                    .iter()
+                    .any(|(path, _, _)| RULES_FILE_NAMES.iter().any(|name| path.as_ref() == *name))
+                {
                    self.enqueue_system_prompt_reload();
                }
            }
@@ -368,7 +369,7 @@ impl ThreadStore {
            .into_iter()
            .filter_map(|name| {
                worktree
-                    .entry_for_path(RelPath::unix(name).unwrap())
+                    .entry_for_path(name)
                    .filter(|entry| entry.is_file())
                    .map(|entry| entry.path.clone())
            })
--- a/crates/agent2/src/agent.rs
+++ b/crates/agent2/src/agent.rs
@@ -1418,7 +1418,6 @@ mod tests {
    }

    #[gpui::test]
-    #[cfg_attr(target_os = "windows", ignore)] // TODO: Fix this test on Windows
    async fn test_save_load_thread(cx: &mut TestAppContext) {
        init_test(cx);
        let fs = FakeFs::new(cx.executor());
@@ -1498,7 +1497,8 @@ mod tests {
        model.send_last_completion_stream_text_chunk("Lorem.");
        model.end_last_completion_stream();
        cx.run_until_parked();
-        summary_model.send_last_completion_stream_text_chunk("Explaining /a/b.md");
+        summary_model
+            .send_last_completion_stream_text_chunk(&format!("Explaining {}", path!("/a/b.md")));
        summary_model.end_last_completion_stream();

        send.await.unwrap();
@@ -1538,7 +1538,7 @@ mod tests {
            history_entries(&history_store, cx),
            vec![(
                HistoryEntryId::AcpThread(session_id.clone()),
-                "Explaining /a/b.md".into()
+                format!("Explaining {}", path!("/a/b.md"))
            )]
        );
        let acp_thread = agent
--- a/crates/agent2/src/history_store.rs
+++ b/crates/agent2/src/history_store.rs
@@ -262,7 +262,7 @@ impl HistoryStore {
            .iter()
            .filter_map(|entry| match entry {
                HistoryEntryId::TextThread(path) => path.file_name().map(|file| {
-                    SerializedRecentOpen::TextThread(file.to_string_lossy().to_string())
+                    SerializedRecentOpen::TextThread(file.to_string_lossy().into_owned())
                }),
                HistoryEntryId::AcpThread(id) => {
                    Some(SerializedRecentOpen::AcpThread(id.to_string()))
--- a/crates/agent2/src/thread.rs
+++ b/crates/agent2/src/thread.rs
@@ -15,10 +15,11 @@ use agent_settings::{
 use anyhow::{Context as _, Result, anyhow};
 use assistant_tool::adapt_schema_to_format;
 use chrono::{DateTime, Utc};
-use client::{ModelRequestUsage, RequestUsage};
-use cloud_llm_client::{CompletionIntent, CompletionRequestStatus, UsageLimit};
+use client::{ModelRequestUsage, RequestUsage, UserStore};
+use cloud_llm_client::{CompletionIntent, CompletionRequestStatus, Plan, UsageLimit};
 use collections::{HashMap, HashSet, IndexMap};
 use fs::Fs;
+use futures::stream;
 use futures::{
    FutureExt,
    channel::{mpsc, oneshot},
@@ -34,7 +35,7 @@ use language_model::{
    LanguageModelImage, LanguageModelProviderId, LanguageModelRegistry, LanguageModelRequest,
    LanguageModelRequestMessage, LanguageModelRequestTool, LanguageModelToolResult,
    LanguageModelToolResultContent, LanguageModelToolSchemaFormat, LanguageModelToolUse,
-    LanguageModelToolUseId, Role, SelectedModel, StopReason, TokenUsage,
+    LanguageModelToolUseId, Role, SelectedModel, StopReason, TokenUsage, ZED_CLOUD_PROVIDER_ID,
 };
 use project::{
    Project,
@@ -585,6 +586,7 @@ pub struct Thread {
    pending_title_generation: Option<Task<()>>,
    summary: Option<SharedString>,
    messages: Vec<Message>,
+    user_store: Entity<UserStore>,
    completion_mode: CompletionMode,
    /// Holds the task that handles agent interaction until the end of the turn.
    /// Survives across multiple requests as the model performs tool calls and
@@ -641,6 +643,7 @@ impl Thread {
            pending_title_generation: None,
            summary: None,
            messages: Vec::new(),
+            user_store: project.read(cx).user_store(),
            completion_mode: AgentSettings::get_global(cx).preferred_completion_mode,
            running_turn: None,
            pending_message: None,
@@ -820,6 +823,7 @@ impl Thread {
            pending_title_generation: None,
            summary: db_thread.detailed_summary,
            messages: db_thread.messages,
+            user_store: project.read(cx).user_store(),
            completion_mode: db_thread.completion_mode.unwrap_or_default(),
            running_turn: None,
            pending_message: None,
@@ -898,7 +902,7 @@ impl Thread {
            // Get worktree path and snapshot
            let worktree_info = cx.update(|app_cx| {
                let worktree = worktree.read(app_cx);
-                let path = worktree.abs_path().to_string_lossy().to_string();
+                let path = worktree.abs_path().to_string_lossy().into_owned();
                let snapshot = worktree.snapshot();
                (path, snapshot)
            });
@@ -1249,12 +1253,12 @@ impl Thread {
            );

            log::debug!("Calling model.stream_completion, attempt {}", attempt);
-            let mut events = model
-                .stream_completion(request, cx)
-                .await
-                .map_err(|error| anyhow!(error))?;
+
+            let (mut events, mut error) = match model.stream_completion(request, cx).await {
+                Ok(events) => (events, None),
+                Err(err) => (stream::empty().boxed(), Some(err)),
+            };
            let mut tool_results = FuturesUnordered::new();
-            let mut error = None;
            while let Some(event) = events.next().await {
                log::trace!("Received completion event: {:?}", event);
                match event {
@@ -1302,8 +1306,10 @@ impl Thread {

            if let Some(error) = error {
                attempt += 1;
-                let retry =
-                    this.update(cx, |this, _| this.handle_completion_error(error, attempt))??;
+                let retry = this.update(cx, |this, cx| {
+                    let user_store = this.user_store.read(cx);
+                    this.handle_completion_error(error, attempt, user_store.plan())
+                })??;
                let timer = cx.background_executor().timer(retry.duration);
                event_stream.send_retry(retry);
                timer.await;
@@ -1330,8 +1336,23 @@ impl Thread {
        &mut self,
        error: LanguageModelCompletionError,
        attempt: u8,
+        plan: Option<Plan>,
    ) -> Result<acp_thread::RetryStatus> {
-        if self.completion_mode == CompletionMode::Normal {
+        let Some(model) = self.model.as_ref() else {
+            return Err(anyhow!(error));
+        };
+
+        let auto_retry = if model.provider_id() == ZED_CLOUD_PROVIDER_ID {
+            match plan {
+                Some(Plan::V2(_)) => true,
+                Some(Plan::V1(_)) => self.completion_mode == CompletionMode::Burn,
+                None => false,
+            }
+        } else {
+            true
+        };
+
+        if !auto_retry {
            return Err(anyhow!(error));
        }

--- a/crates/agent2/src/tools/edit_file_tool.rs
+++ b/crates/agent2/src/tools/edit_file_tool.rs
@@ -218,7 +218,7 @@ impl AgentTool for EditFileTool {
                        .read(cx)
                        .short_full_path_for_project_path(&project_path, cx)
                })
-                .unwrap_or(input.path.to_string_lossy().to_string())
+                .unwrap_or(input.path.to_string_lossy().into_owned())
                .into(),
            Err(raw_input) => {
                if let Some(input) =
@@ -476,7 +476,7 @@ impl AgentTool for EditFileTool {
    ) -> Result<()> {
        event_stream.update_diff(cx.new(|cx| {
            Diff::finalized(
-                output.input_path.to_string_lossy().to_string(),
+                output.input_path.to_string_lossy().into_owned(),
                Some(output.old_text.to_string()),
                output.new_text,
                self.language_registry.clone(),
--- a/crates/agent2/src/tools/open_tool.rs
+++ b/crates/agent2/src/tools/open_tool.rs
@@ -104,7 +104,7 @@ mod tests {
    async fn test_to_absolute_path(cx: &mut TestAppContext) {
        init_test(cx);
        let temp_dir = TempDir::new().expect("Failed to create temp directory");
-        let temp_path = temp_dir.path().to_string_lossy().to_string();
+        let temp_path = temp_dir.path().to_string_lossy().into_owned();

        let fs = FakeFs::new(cx.executor());
        fs.insert_tree(
--- a/crates/agent_servers/Cargo.toml
+++ b/crates/agent_servers/Cargo.toml
@@ -47,6 +47,8 @@ task.workspace = true
 tempfile.workspace = true
 thiserror.workspace = true
 ui.workspace = true
+terminal.workspace = true
+uuid.workspace = true
 util.workspace = true
 watch.workspace = true
 workspace-hack.workspace = true
--- a/crates/agent_servers/src/acp.rs
+++ b/crates/agent_servers/src/acp.rs
@@ -9,6 +9,7 @@ use futures::io::BufReader;
 use project::Project;
 use project::agent_server_store::AgentServerCommand;
 use serde::Deserialize;
+use task::Shell;
 use util::ResultExt as _;

 use std::path::PathBuf;
@@ -19,7 +20,9 @@ use thiserror::Error;
 use anyhow::{Context as _, Result};
 use gpui::{App, AppContext as _, AsyncApp, Entity, SharedString, Task, WeakEntity};

-use acp_thread::{AcpThread, AuthRequired, LoadError};
+use acp_thread::{AcpThread, AuthRequired, LoadError, TerminalProviderEvent};
+use terminal::TerminalBuilder;
+use terminal::terminal_settings::{AlternateScroll, CursorShape};

 #[derive(Debug, Error)]
 #[error("Unsupported version")]
@@ -79,7 +82,7 @@ impl AcpConnection {
        is_remote: bool,
        cx: &mut AsyncApp,
    ) -> Result<Self> {
-        let mut child = util::command::new_smol_command(command.path);
+        let mut child = util::command::new_smol_command(&command.path);
        child
            .args(command.args.iter().map(|arg| arg.as_str()))
            .envs(command.env.iter().flatten())
@@ -94,6 +97,11 @@ impl AcpConnection {
        let stdout = child.stdout.take().context("Failed to take stdout")?;
        let stdin = child.stdin.take().context("Failed to take stdin")?;
        let stderr = child.stderr.take().context("Failed to take stderr")?;
+        log::info!(
+            "Spawning external agent server: {:?}, {:?}",
+            command.path,
+            command.args
+        );
        log::trace!("Spawned (pid: {})", child.id());

        let sessions = Rc::new(RefCell::new(HashMap::default()));
@@ -380,6 +388,10 @@ impl AgentConnection for AcpConnection {
            match result {
                Ok(response) => Ok(response),
                Err(err) => {
+                    if err.code == acp::ErrorCode::AUTH_REQUIRED.code {
+                        return Err(anyhow!(acp::Error::auth_required()));
+                    }
+
                    if err.code != ErrorCode::INTERNAL_ERROR.code {
                        anyhow::bail!(err)
                    }
@@ -696,10 +708,100 @@ impl acp::Client for ClientDelegate {
            }
        }

+        // Clone so we can inspect meta both before and after handing off to the thread
+        let update_clone = notification.update.clone();
+
+        // Pre-handle: if a ToolCall carries terminal_info, create/register a display-only terminal.
+        if let acp::SessionUpdate::ToolCall(tc) = &update_clone {
+            if let Some(meta) = &tc.meta {
+                if let Some(terminal_info) = meta.get("terminal_info") {
+                    if let Some(id_str) = terminal_info.get("terminal_id").and_then(|v| v.as_str())
+                    {
+                        let terminal_id = acp::TerminalId(id_str.into());
+                        let cwd = terminal_info
+                            .get("cwd")
+                            .and_then(|v| v.as_str().map(PathBuf::from));
+
+                        // Create a minimal display-only lower-level terminal and register it.
+                        let _ = session.thread.update(&mut self.cx.clone(), |thread, cx| {
+                            let builder = TerminalBuilder::new_display_only(
+                                CursorShape::default(),
+                                AlternateScroll::On,
+                                None,
+                                0,
+                            )?;
+                            let lower = cx.new(|cx| builder.subscribe(cx));
+                            thread.on_terminal_provider_event(
+                                TerminalProviderEvent::Created {
+                                    terminal_id: terminal_id.clone(),
+                                    label: tc.title.clone(),
+                                    cwd,
+                                    output_byte_limit: None,
+                                    terminal: lower,
+                                },
+                                cx,
+                            );
+                            anyhow::Ok(())
+                        });
+                    }
+                }
+            }
+        }
+
+        // Forward the update to the acp_thread as usual.
        session.thread.update(&mut self.cx.clone(), |thread, cx| {
-            thread.handle_session_update(notification.update, cx)
+            thread.handle_session_update(notification.update.clone(), cx)
        })??;

+        // Post-handle: stream terminal output/exit if present on ToolCallUpdate meta.
+        if let acp::SessionUpdate::ToolCallUpdate(tcu) = &update_clone {
+            if let Some(meta) = &tcu.meta {
+                if let Some(term_out) = meta.get("terminal_output") {
+                    if let Some(id_str) = term_out.get("terminal_id").and_then(|v| v.as_str()) {
+                        let terminal_id = acp::TerminalId(id_str.into());
+                        if let Some(s) = term_out.get("data").and_then(|v| v.as_str()) {
+                            let data = s.as_bytes().to_vec();
+                            let _ = session.thread.update(&mut self.cx.clone(), |thread, cx| {
+                                thread.on_terminal_provider_event(
+                                    TerminalProviderEvent::Output {
+                                        terminal_id: terminal_id.clone(),
+                                        data,
+                                    },
+                                    cx,
+                                );
+                            });
+                        }
+                    }
+                }
+
+                // terminal_exit
+                if let Some(term_exit) = meta.get("terminal_exit") {
+                    if let Some(id_str) = term_exit.get("terminal_id").and_then(|v| v.as_str()) {
+                        let terminal_id = acp::TerminalId(id_str.into());
+                        let status = acp::TerminalExitStatus {
+                            exit_code: term_exit
+                                .get("exit_code")
+                                .and_then(|v| v.as_u64())
+                                .map(|i| i as u32),
+                            signal: term_exit
+                                .get("signal")
+                                .and_then(|v| v.as_str().map(|s| s.to_string())),
+                            meta: None,
+                        };
+                        let _ = session.thread.update(&mut self.cx.clone(), |thread, cx| {
+                            thread.on_terminal_provider_event(
+                                TerminalProviderEvent::Exit {
+                                    terminal_id: terminal_id.clone(),
+                                    status,
+                                },
+                                cx,
+                            );
+                        });
+                    }
+                }
+            }
+        }
+
        Ok(())
    }

@@ -707,25 +809,68 @@ impl acp::Client for ClientDelegate {
        &self,
        args: acp::CreateTerminalRequest,
    ) -> Result<acp::CreateTerminalResponse, acp::Error> {
-        let terminal = self
-            .session_thread(&args.session_id)?
-            .update(&mut self.cx.clone(), |thread, cx| {
-                thread.create_terminal(
-                    args.command,
-                    args.args,
-                    args.env,
-                    args.cwd,
-                    args.output_byte_limit,
+        let thread = self.session_thread(&args.session_id)?;
+        let project = thread.read_with(&self.cx, |thread, _cx| thread.project().clone())?;
+
+        let mut env = if let Some(dir) = &args.cwd {
+            project
+                .update(&mut self.cx.clone(), |project, cx| {
+                    project.directory_environment(&task::Shell::System, dir.clone().into(), cx)
+                })?
+                .await
+                .unwrap_or_default()
+        } else {
+            Default::default()
+        };
+        for var in args.env {
+            env.insert(var.name, var.value);
+        }
+
+        // Use remote shell or default system shell, as appropriate
+        let shell = project
+            .update(&mut self.cx.clone(), |project, cx| {
+                project
+                    .remote_client()
+                    .and_then(|r| r.read(cx).default_system_shell())
+                    .map(Shell::Program)
+            })?
+            .unwrap_or(task::Shell::System);
+        let (task_command, task_args) = task::ShellBuilder::new(&shell)
+            .redirect_stdin_to_dev_null()
+            .build(Some(args.command.clone()), &args.args);
+
+        let terminal_entity = project
+            .update(&mut self.cx.clone(), |project, cx| {
+                project.create_terminal_task(
+                    task::SpawnInTerminal {
+                        command: Some(task_command),
+                        args: task_args,
+                        cwd: args.cwd.clone(),
+                        env,
+                        ..Default::default()
+                    },
                    cx,
                )
            })?
            .await?;
-        Ok(
-            terminal.read_with(&self.cx, |terminal, _| acp::CreateTerminalResponse {
-                terminal_id: terminal.id().clone(),
-                meta: None,
-            })?,
-        )
+
+        // Register with renderer
+        let terminal_entity = thread.update(&mut self.cx.clone(), |thread, cx| {
+            thread.register_terminal_created(
+                acp::TerminalId(uuid::Uuid::new_v4().to_string().into()),
+                format!("{} {}", args.command, args.args.join(" ")),
+                args.cwd.clone(),
+                args.output_byte_limit,
+                terminal_entity,
+                cx,
+            )
+        })?;
+        let terminal_id =
+            terminal_entity.read_with(&self.cx, |terminal, _| terminal.id().clone())?;
+        Ok(acp::CreateTerminalResponse {
+            terminal_id,
+            meta: None,
+        })
    }

    async fn kill_terminal_command(
--- a/crates/agent_servers/src/agent_servers.rs
+++ b/crates/agent_servers/src/agent_servers.rs
@@ -1,5 +1,6 @@
 mod acp;
 mod claude;
+mod codex;
 mod custom;
 mod gemini;

@@ -8,6 +9,7 @@ pub mod e2e_tests;

 pub use claude::*;
 use client::ProxySettings;
+pub use codex::*;
 use collections::HashMap;
 pub use custom::*;
 use fs::Fs;
@@ -99,6 +101,9 @@ pub fn load_proxy_env(cx: &mut App) -> HashMap<String, String> {

    if let Some(no_proxy) = read_no_proxy_from_env() {
        env.insert("NO_PROXY".to_owned(), no_proxy);
+    } else if proxy_url.is_some() {
+        // We sometimes need local MCP servers that we don't want to proxy
+        env.insert("NO_PROXY".to_owned(), "localhost,127.0.0.1".to_owned());
    }

    env
--- a/crates/agent_servers/src/claude.rs
+++ b/crates/agent_servers/src/claude.rs
@@ -62,7 +62,7 @@ impl AgentServer for ClaudeCode {
        cx: &mut App,
    ) -> Task<Result<(Rc<dyn AgentConnection>, Option<task::SpawnInTerminal>)>> {
        let name = self.name();
-        let root_dir = root_dir.map(|root_dir| root_dir.to_string_lossy().to_string());
+        let root_dir = root_dir.map(|root_dir| root_dir.to_string_lossy().into_owned());
        let is_remote = delegate.project.read(cx).is_via_remote_server();
        let store = delegate.store.downgrade();
        let extra_env = load_proxy_env(cx);
--- a/crates/agent_servers/src/codex.rs
+++ b/crates/agent_servers/src/codex.rs
@@ -0,0 +1,80 @@
+use std::rc::Rc;
+use std::{any::Any, path::Path};
+
+use crate::{AgentServer, AgentServerDelegate, load_proxy_env};
+use acp_thread::AgentConnection;
+use anyhow::{Context as _, Result};
+use gpui::{App, SharedString, Task};
+use project::agent_server_store::CODEX_NAME;
+
+#[derive(Clone)]
+pub struct Codex;
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use super::*;
+
+    crate::common_e2e_tests!(async |_, _, _| Codex, allow_option_id = "proceed_once");
+}
+
+impl AgentServer for Codex {
+    fn telemetry_id(&self) -> &'static str {
+        "codex"
+    }
+
+    fn name(&self) -> SharedString {
+        "Codex".into()
+    }
+
+    fn logo(&self) -> ui::IconName {
+        ui::IconName::AiOpenAi
+    }
+
+    fn connect(
+        &self,
+        root_dir: Option<&Path>,
+        delegate: AgentServerDelegate,
+        cx: &mut App,
+    ) -> Task<Result<(Rc<dyn AgentConnection>, Option<task::SpawnInTerminal>)>> {
+        let name = self.name();
+        let root_dir = root_dir.map(|root_dir| root_dir.to_string_lossy().into_owned());
+        let is_remote = delegate.project.read(cx).is_via_remote_server();
+        let store = delegate.store.downgrade();
+        let extra_env = load_proxy_env(cx);
+        let default_mode = self.default_mode(cx);
+
+        cx.spawn(async move |cx| {
+            let (command, root_dir, login) = store
+                .update(cx, |store, cx| {
+                    let agent = store
+                        .get_external_agent(&CODEX_NAME.into())
+                        .context("Codex is not registered")?;
+                    anyhow::Ok(agent.get_command(
+                        root_dir.as_deref(),
+                        extra_env,
+                        delegate.status_tx,
+                        // For now, report that there are no updates.
+                        // (A future PR will use the GitHub Releases API to fetch them.)
+                        delegate.new_version_available,
+                        &mut cx.to_async(),
+                    ))
+                })??
+                .await?;
+
+            let connection = crate::acp::connect(
+                name,
+                command,
+                root_dir.as_ref(),
+                default_mode,
+                is_remote,
+                cx,
+            )
+            .await?;
+            Ok((connection, login))
+        })
+    }
+
+    fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
+        self
+    }
+}
--- a/crates/agent_servers/src/custom.rs
+++ b/crates/agent_servers/src/custom.rs
@@ -67,7 +67,7 @@ impl crate::AgentServer for CustomAgentServer {
        cx: &mut App,
    ) -> Task<Result<(Rc<dyn AgentConnection>, Option<task::SpawnInTerminal>)>> {
        let name = self.name();
-        let root_dir = root_dir.map(|root_dir| root_dir.to_string_lossy().to_string());
+        let root_dir = root_dir.map(|root_dir| root_dir.to_string_lossy().into_owned());
        let is_remote = delegate.project.read(cx).is_via_remote_server();
        let default_mode = self.default_mode(cx);
        let store = delegate.store.downgrade();
--- a/crates/agent_servers/src/e2e_tests.rs
+++ b/crates/agent_servers/src/e2e_tests.rs
@@ -483,6 +483,13 @@ pub async fn init_test(cx: &mut TestAppContext) -> Arc<FakeFs> {
                    default_mode: None,
                }),
                gemini: Some(crate::gemini::tests::local_command().into()),
+                codex: Some(BuiltinAgentServerSettings {
+                    path: Some("codex-acp".into()),
+                    args: None,
+                    env: None,
+                    ignore_system_version: None,
+                    default_mode: None,
+                }),
                custom: collections::HashMap::default(),
            },
            cx,
--- a/crates/agent_servers/src/gemini.rs
+++ b/crates/agent_servers/src/gemini.rs
@@ -31,7 +31,7 @@ impl AgentServer for Gemini {
        cx: &mut App,
    ) -> Task<Result<(Rc<dyn AgentConnection>, Option<task::SpawnInTerminal>)>> {
        let name = self.name();
-        let root_dir = root_dir.map(|root_dir| root_dir.to_string_lossy().to_string());
+        let root_dir = root_dir.map(|root_dir| root_dir.to_string_lossy().into_owned());
        let is_remote = delegate.project.read(cx).is_via_remote_server();
        let store = delegate.store.downgrade();
        let mut extra_env = load_proxy_env(cx);
--- a/crates/agent_settings/src/agent_settings.rs
+++ b/crates/agent_settings/src/agent_settings.rs
@@ -151,7 +151,7 @@ impl Default for AgentProfileId {
 }

 impl Settings for AgentSettings {
-    fn from_settings(content: &settings::SettingsContent, _cx: &mut App) -> Self {
+    fn from_settings(content: &settings::SettingsContent) -> Self {
        let agent = content.agent.clone().unwrap();
        Self {
            enabled: agent.enabled.unwrap(),
--- a/crates/agent_ui/Cargo.toml
+++ b/crates/agent_ui/Cargo.toml
@@ -80,7 +80,6 @@ serde.workspace = true
 serde_json.workspace = true
 serde_json_lenient.workspace = true
 settings.workspace = true
-shlex.workspace = true
 smol.workspace = true
 streaming_diff.workspace = true
 task.workspace = true
--- a/crates/agent_ui/src/acp/entry_view_state.rs
+++ b/crates/agent_ui/src/acp/entry_view_state.rs
@@ -203,7 +203,7 @@ impl EntryViewState {
        self.entries.drain(range);
    }

-    pub fn agent_font_size_changed(&mut self, cx: &mut App) {
+    pub fn agent_ui_font_size_changed(&mut self, cx: &mut App) {
        for entry in self.entries.iter() {
            match entry {
                Entry::UserMessage { .. } | Entry::AssistantMessage { .. } => {}
@@ -387,7 +387,7 @@ fn diff_editor_text_style_refinement(cx: &mut App) -> TextStyleRefinement {
        font_size: Some(
            TextSize::Small
                .rems(cx)
-                .to_pixels(ThemeSettings::get_global(cx).agent_font_size(cx))
+                .to_pixels(ThemeSettings::get_global(cx).agent_ui_font_size(cx))
                .into(),
        ),
        ..Default::default()
@@ -414,7 +414,6 @@ mod tests {
    use project::Project;
    use serde_json::json;
    use settings::{Settings as _, SettingsStore};
-    use theme::ThemeSettings;
    use util::path;
    use workspace::Workspace;

@@ -544,7 +543,7 @@ mod tests {
            Project::init_settings(cx);
            AgentSettings::register(cx);
            workspace::init_settings(cx);
-            ThemeSettings::register(cx);
+            theme::init(theme::LoadThemes::JustBase, cx);
            release_channel::init(SemanticVersion::default(), cx);
            EditorSettings::register(cx);
        });
--- a/crates/agent_ui/src/acp/message_editor.rs
+++ b/crates/agent_ui/src/acp/message_editor.rs
@@ -76,7 +76,7 @@ pub enum MessageEditorEvent {

 impl EventEmitter<MessageEditorEvent> for MessageEditor {}

-const COMMAND_HINT_INLAY_ID: usize = 0;
+const COMMAND_HINT_INLAY_ID: u32 = 0;

 impl MessageEditor {
    pub fn new(
@@ -290,18 +290,18 @@ impl MessageEditor {
        let snapshot = self
            .editor
            .update(cx, |editor, cx| editor.snapshot(window, cx));
-        let Some((excerpt_id, _, _)) = snapshot.buffer_snapshot.as_singleton() else {
+        let Some((excerpt_id, _, _)) = snapshot.buffer_snapshot().as_singleton() else {
            return Task::ready(());
        };
        let Some(start_anchor) = snapshot
-            .buffer_snapshot
+            .buffer_snapshot()
            .anchor_in_excerpt(*excerpt_id, start)
        else {
            return Task::ready(());
        };
        let end_anchor = snapshot
-            .buffer_snapshot
-            .anchor_before(start_anchor.to_offset(&snapshot.buffer_snapshot) + content_len + 1);
+            .buffer_snapshot()
+            .anchor_before(start_anchor.to_offset(&snapshot.buffer_snapshot()) + content_len + 1);

        let crease = if let MentionUri::File { abs_path } = &mention_uri
            && let Some(extension) = abs_path.extension()
@@ -718,7 +718,7 @@ impl MessageEditor {
                            continue;
                        };

-                        let crease_range = crease.range().to_offset(&snapshot.buffer_snapshot);
+                        let crease_range = crease.range().to_offset(&snapshot.buffer_snapshot());
                        if crease_range.start > ix {
                            //todo(): Custom slash command ContentBlock?
                            // let chunk = if prevent_slash_commands
@@ -865,11 +865,11 @@ impl MessageEditor {
                self.editor.update(cx, |message_editor, cx| {
                    let snapshot = message_editor.snapshot(window, cx);
                    let (excerpt_id, _, buffer_snapshot) =
-                        snapshot.buffer_snapshot.as_singleton().unwrap();
+                        snapshot.buffer_snapshot().as_singleton().unwrap();

                    let text_anchor = buffer_snapshot.anchor_before(buffer_snapshot.len());
                    let multibuffer_anchor = snapshot
-                        .buffer_snapshot
+                        .buffer_snapshot()
                        .anchor_in_excerpt(*excerpt_id, text_anchor);
                    message_editor.edit(
                        [(
@@ -1299,7 +1299,7 @@ impl Render for MessageEditor {
                    font_family: settings.buffer_font.family.clone(),
                    font_fallbacks: settings.buffer_font.fallbacks.clone(),
                    font_features: settings.buffer_font.features.clone(),
-                    font_size: settings.buffer_font_size(cx).into(),
+                    font_size: settings.agent_buffer_font_size(cx).into(),
                    line_height: relative(settings.buffer_line_height.value()),
                    ..Default::default()
                };
@@ -1550,7 +1550,7 @@ impl MentionSet {

    fn remove_invalid(&mut self, snapshot: EditorSnapshot) {
        for (crease_id, crease) in snapshot.crease_snapshot.creases() {
-            if !crease.range().start.is_valid(&snapshot.buffer_snapshot) {
+            if !crease.range().start.is_valid(&snapshot.buffer_snapshot()) {
                self.mentions.remove(&crease_id);
            }
        }
--- a/crates/agent_ui/src/acp/thread_view.rs
+++ b/crates/agent_ui/src/acp/thread_view.rs
@@ -9,7 +9,7 @@ use agent_client_protocol::{self as acp, PromptCapabilities};
 use agent_servers::{AgentServer, AgentServerDelegate};
 use agent_settings::{AgentProfileId, AgentSettings, CompletionMode};
 use agent2::{DbThreadMetadata, HistoryEntry, HistoryEntryId, HistoryStore, NativeAgentServer};
-use anyhow::{Context as _, Result, anyhow, bail};
+use anyhow::{Result, anyhow, bail};
 use arrayvec::ArrayVec;
 use audio::{Audio, Sound};
 use buffer_diff::BufferDiff;
@@ -26,7 +26,7 @@ use gpui::{
    CursorStyle, EdgesRefinement, ElementId, Empty, Entity, FocusHandle, Focusable, Hsla, Length,
    ListOffset, ListState, PlatformDisplay, SharedString, StyleRefinement, Subscription, Task,
    TextStyle, TextStyleRefinement, UnderlineStyle, WeakEntity, Window, WindowHandle, div,
-    ease_in_out, linear_color_stop, linear_gradient, list, point, prelude::*, pulsating_between,
+    ease_in_out, linear_color_stop, linear_gradient, list, point, pulsating_between,
 };
 use language::Buffer;

@@ -289,8 +289,9 @@ pub struct AcpThreadView {
    available_commands: Rc<RefCell<Vec<acp::AvailableCommand>>>,
    is_loading_contents: bool,
    new_server_version_available: Option<SharedString>,
+    resume_thread_metadata: Option<DbThreadMetadata>,
    _cancel_task: Option<Task<()>>,
-    _subscriptions: [Subscription; 4],
+    _subscriptions: [Subscription; 5],
 }

 enum ThreadState {
@@ -380,11 +381,17 @@ impl AcpThreadView {
            )
        });

+        let agent_server_store = project.read(cx).agent_server_store().clone();
        let subscriptions = [
-            cx.observe_global_in::<SettingsStore>(window, Self::agent_font_size_changed),
-            cx.observe_global_in::<AgentFontSize>(window, Self::agent_font_size_changed),
+            cx.observe_global_in::<SettingsStore>(window, Self::agent_ui_font_size_changed),
+            cx.observe_global_in::<AgentFontSize>(window, Self::agent_ui_font_size_changed),
            cx.subscribe_in(&message_editor, window, Self::handle_message_editor_event),
            cx.subscribe_in(&entry_view_state, window, Self::handle_entry_view_event),
+            cx.subscribe_in(
+                &agent_server_store,
+                window,
+                Self::handle_agent_servers_updated,
+            ),
        ];

        Self {
@@ -392,7 +399,14 @@ impl AcpThreadView {
            workspace: workspace.clone(),
            project: project.clone(),
            entry_view_state,
-            thread_state: Self::initial_state(agent, resume_thread, workspace, project, window, cx),
+            thread_state: Self::initial_state(
+                agent.clone(),
+                resume_thread.clone(),
+                workspace.clone(),
+                project.clone(),
+                window,
+                cx,
+            ),
            login: None,
            message_editor,
            model_selector: None,
@@ -421,13 +435,14 @@ impl AcpThreadView {
            _cancel_task: None,
            focus_handle: cx.focus_handle(),
            new_server_version_available: None,
+            resume_thread_metadata: resume_thread,
        }
    }

    fn reset(&mut self, window: &mut Window, cx: &mut Context<Self>) {
        self.thread_state = Self::initial_state(
            self.agent.clone(),
-            None,
+            self.resume_thread_metadata.clone(),
            self.workspace.clone(),
            self.project.clone(),
            window,
@@ -775,6 +790,25 @@ impl AcpThreadView {
        cx.notify();
    }

+    fn handle_agent_servers_updated(
+        &mut self,
+        _agent_server_store: &Entity<project::AgentServerStore>,
+        _event: &project::AgentServersUpdated,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        // If we're in a LoadError state OR have a thread_error set (which can happen
+        // when agent.connect() fails during loading), retry loading the thread.
+        // This handles the case where a thread is restored before authentication completes.
+        let should_retry =
+            matches!(&self.thread_state, ThreadState::LoadError(_)) || self.thread_error.is_some();
+
+        if should_retry {
+            self.thread_error = None;
+            self.reset(window, cx);
+        }
+    }
+
    pub fn workspace(&self) -> &WeakEntity<Workspace> {
        &self.workspace
    }
@@ -1012,30 +1046,33 @@ impl AcpThreadView {
            };

            let connection = thread.read(cx).connection().clone();
-            if !connection
-                .auth_methods()
-                .iter()
-                .any(|method| method.id.0.as_ref() == "claude-login")
-            {
+            let can_login = !connection.auth_methods().is_empty() || self.login.is_some();
+            // Does the agent have a specific logout command? Prefer that in case they need to reset internal state.
+            let logout_supported = text == "/logout"
+                && self
+                    .available_commands
+                    .borrow()
+                    .iter()
+                    .any(|command| command.name == "logout");
+            if can_login && !logout_supported {
+                let this = cx.weak_entity();
+                let agent = self.agent.clone();
+                window.defer(cx, |window, cx| {
+                    Self::handle_auth_required(
+                        this,
+                        AuthRequired {
+                            description: None,
+                            provider_id: None,
+                        },
+                        agent,
+                        connection,
+                        window,
+                        cx,
+                    );
+                });
+                cx.notify();
                return;
-            };
-            let this = cx.weak_entity();
-            let agent = self.agent.clone();
-            window.defer(cx, |window, cx| {
-                Self::handle_auth_required(
-                    this,
-                    AuthRequired {
-                        description: None,
-                        provider_id: None,
-                    },
-                    agent,
-                    connection,
-                    window,
-                    cx,
-                );
-            });
-            cx.notify();
-            return;
+            }
        }

        self.send_impl(self.message_editor.clone(), window, cx)
@@ -1579,31 +1616,20 @@ impl AcpThreadView {
            return Task::ready(Ok(()));
        };
        let project = workspace.read(cx).project().clone();
-        let cwd = project.read(cx).first_project_directory(cx);
-        let shell = project.read(cx).terminal_settings(&cwd, cx).shell.clone();

        window.spawn(cx, async move |cx| {
            let mut task = login.clone();
-            task.command = task
-                .command
-                .map(|command| anyhow::Ok(shlex::try_quote(&command)?.to_string()))
-                .transpose()?;
-            task.args = task
-                .args
-                .iter()
-                .map(|arg| {
-                    Ok(shlex::try_quote(arg)
-                        .context("Failed to quote argument")?
-                        .to_string())
-                })
-                .collect::<Result<Vec<_>>>()?;
+            task.shell = task::Shell::WithArguments {
+                program: task.command.take().expect("login command should be set"),
+                args: std::mem::take(&mut task.args),
+                title_override: None
+            };
            task.full_label = task.label.clone();
            task.id = task::TaskId(format!("external-agent-{}-login", task.label));
            task.command_label = task.label.clone();
            task.use_new_terminal = true;
            task.allow_concurrent_runs = true;
            task.hide = task::HideStrategy::Always;
-            task.shell = shell;

            let terminal = terminal_panel.update_in(cx, |terminal_panel, window, cx| {
                terminal_panel.spawn_task(&task, window, cx)
@@ -2702,7 +2728,7 @@ impl AcpThreadView {
        let output_line_count = output.map(|output| output.content_line_count).unwrap_or(0);

        let command_failed = command_finished
-            && output.is_some_and(|o| o.exit_status.is_none_or(|status| !status.success()));
+            && output.is_some_and(|o| o.exit_status.is_some_and(|status| !status.success()));

        let time_elapsed = if let Some(output) = output {
            output.ended_at.duration_since(started_at)
@@ -2725,7 +2751,7 @@ impl AcpThreadView {

        let working_dir = working_dir
            .as_ref()
-            .map(|path| format!("{}", path.display()))
+            .map(|path| path.display().to_string())
            .unwrap_or_else(|| "current directory".to_string());

        let is_expanded = self.expanded_tool_calls.contains(&tool_call.id);
@@ -3363,6 +3389,12 @@ impl AcpThreadView {
            .into_any_element()
    }

+    fn activity_bar_bg(&self, cx: &Context<Self>) -> Hsla {
+        let editor_bg_color = cx.theme().colors().editor_background;
+        let active_color = cx.theme().colors().element_selected;
+        editor_bg_color.blend(active_color.opacity(0.3))
+    }
+
    fn render_activity_bar(
        &self,
        thread_entity: &Entity<AcpThread>,
@@ -3378,10 +3410,6 @@ impl AcpThreadView {
            return None;
        }

-        let editor_bg_color = cx.theme().colors().editor_background;
-        let active_color = cx.theme().colors().element_selected;
-        let bg_edit_files_disclosure = editor_bg_color.blend(active_color.opacity(0.3));
-
        // Temporarily always enable ACP edit controls. This is temporary, to lessen the
        // impact of a nasty bug that causes them to sometimes be disabled when they shouldn't
        // be, which blocks you from being able to accept or reject edits. This switches the
@@ -3392,7 +3420,7 @@ impl AcpThreadView {
        v_flex()
            .mt_1()
            .mx_2()
-            .bg(bg_edit_files_disclosure)
+            .bg(self.activity_bar_bg(cx))
            .border_1()
            .border_b_0()
            .border_color(cx.theme().colors().border)
@@ -3433,27 +3461,33 @@ impl AcpThreadView {
            .into()
    }

-    fn render_plan_summary(&self, plan: &Plan, window: &mut Window, cx: &Context<Self>) -> Div {
+    fn render_plan_summary(
+        &self,
+        plan: &Plan,
+        window: &mut Window,
+        cx: &Context<Self>,
+    ) -> impl IntoElement {
        let stats = plan.stats();

        let title = if let Some(entry) = stats.in_progress_entry
            && !self.plan_expanded
        {
            h_flex()
-                .w_full()
                .cursor_default()
+                .relative()
+                .w_full()
                .gap_1()
-                .text_xs()
-                .text_color(cx.theme().colors().text_muted)
-                .justify_between()
+                .truncate()
                .child(
-                    h_flex()
-                        .gap_1()
-                        .child(
-                            Label::new("Current:")
-                                .size(LabelSize::Small)
-                                .color(Color::Muted),
-                        )
+                    Label::new("Current:")
+                        .size(LabelSize::Small)
+                        .color(Color::Muted),
+                )
+                .child(
+                    div()
+                        .text_xs()
+                        .text_color(cx.theme().colors().text_muted)
+                        .line_clamp(1)
                        .child(MarkdownElement::new(
                            entry.content.clone(),
                            plan_label_markdown_style(&entry.status, window, cx),
@@ -3461,10 +3495,23 @@ impl AcpThreadView {
                )
                .when(stats.pending > 0, |this| {
                    this.child(
-                        Label::new(format!("{} left", stats.pending))
-                            .size(LabelSize::Small)
-                            .color(Color::Muted)
-                            .mr_1(),
+                        h_flex()
+                            .absolute()
+                            .top_0()
+                            .right_0()
+                            .h_full()
+                            .child(div().min_w_8().h_full().bg(linear_gradient(
+                                90.,
+                                linear_color_stop(self.activity_bar_bg(cx), 1.),
+                                linear_color_stop(self.activity_bar_bg(cx).opacity(0.2), 0.),
+                            )))
+                            .child(
+                                div().pr_0p5().bg(self.activity_bar_bg(cx)).child(
+                                    Label::new(format!("{} left", stats.pending))
+                                        .size(LabelSize::Small)
+                                        .color(Color::Muted),
+                                ),
+                            ),
                    )
                })
        } else {
@@ -3494,23 +3541,19 @@ impl AcpThreadView {
        };

        h_flex()
+            .id("plan_summary")
            .p_1()
-            .justify_between()
+            .w_full()
+            .gap_1()
            .when(self.plan_expanded, |this| {
                this.border_b_1().border_color(cx.theme().colors().border)
            })
-            .child(
-                h_flex()
-                    .id("plan_summary")
-                    .w_full()
-                    .gap_1()
-                    .child(Disclosure::new("plan_disclosure", self.plan_expanded))
-                    .child(title)
-                    .on_click(cx.listener(|this, _, _, cx| {
-                        this.plan_expanded = !this.plan_expanded;
-                        cx.notify();
-                    })),
-            )
+            .child(Disclosure::new("plan_disclosure", self.plan_expanded))
+            .child(title)
+            .on_click(cx.listener(|this, _, _, cx| {
+                this.plan_expanded = !this.plan_expanded;
+                cx.notify();
+            }))
    }

    fn render_plan_entries(&self, plan: &Plan, window: &mut Window, cx: &Context<Self>) -> Div {
@@ -3712,13 +3755,10 @@ impl AcpThreadView {
                        None
                    } else {
                        Some(
-                            Label::new(format!(
-                                "{separator}{}{separator}",
-                                parent.display(path_style)
-                            ))
-                            .color(Color::Muted)
-                            .size(LabelSize::XSmall)
-                            .buffer_font(cx),
+                            Label::new(format!("{}{separator}", parent.display(path_style)))
+                                .color(Color::Muted)
+                                .size(LabelSize::XSmall)
+                                .buffer_font(cx),
                        )
                    }
                });
@@ -3762,7 +3802,7 @@ impl AcpThreadView {
                            .id(("file-name", index))
                            .pr_8()
                            .gap_1p5()
-                            .max_w_full()
+                            .w_full()
                            .overflow_x_scroll()
                            .child(file_icon)
                            .child(h_flex().gap_0p5().children(file_name).children(file_path))
@@ -4914,9 +4954,9 @@ impl AcpThreadView {
        )
    }

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

@@ -5546,23 +5586,23 @@ fn default_markdown_style(
        }),
        code_block: StyleRefinement {
            padding: EdgesRefinement {
-                top: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(Pixels(8.)))),
-                left: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(Pixels(8.)))),
-                right: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(Pixels(8.)))),
-                bottom: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(Pixels(8.)))),
+                top: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(8.)))),
+                left: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(8.)))),
+                right: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(8.)))),
+                bottom: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(px(8.)))),
            },
            margin: EdgesRefinement {
-                top: Some(Length::Definite(Pixels(8.).into())),
-                left: Some(Length::Definite(Pixels(0.).into())),
-                right: Some(Length::Definite(Pixels(0.).into())),
-                bottom: Some(Length::Definite(Pixels(12.).into())),
+                top: Some(Length::Definite(px(8.).into())),
+                left: Some(Length::Definite(px(0.).into())),
+                right: Some(Length::Definite(px(0.).into())),
+                bottom: Some(Length::Definite(px(12.).into())),
            },
            border_style: Some(BorderStyle::Solid),
            border_widths: EdgesRefinement {
-                top: Some(AbsoluteLength::Pixels(Pixels(1.))),
-                left: Some(AbsoluteLength::Pixels(Pixels(1.))),
-                right: Some(AbsoluteLength::Pixels(Pixels(1.))),
-                bottom: Some(AbsoluteLength::Pixels(Pixels(1.))),
+                top: Some(AbsoluteLength::Pixels(px(1.))),
+                left: Some(AbsoluteLength::Pixels(px(1.))),
+                right: Some(AbsoluteLength::Pixels(px(1.))),
+                bottom: Some(AbsoluteLength::Pixels(px(1.))),
            },
            border_color: Some(colors.border_variant),
            background: Some(colors.editor_background.into()),
@@ -6047,7 +6087,7 @@ pub(crate) mod tests {
            Project::init_settings(cx);
            AgentSettings::register(cx);
            workspace::init_settings(cx);
-            ThemeSettings::register(cx);
+            theme::init(theme::LoadThemes::JustBase, cx);
            release_channel::init(SemanticVersion::default(), cx);
            EditorSettings::register(cx);
            prompt_store::init(cx)
--- a/crates/agent_ui/src/agent_configuration.rs
+++ b/crates/agent_ui/src/agent_configuration.rs
@@ -15,6 +15,7 @@ use context_server::ContextServerId;
 use editor::{Editor, SelectionEffects, scroll::Autoscroll};
 use extension::ExtensionManifest;
 use extension_host::ExtensionStore;
+use feature_flags::{CodexAcpFeatureFlag, FeatureFlagAppExt as _};
 use fs::Fs;
 use gpui::{
    Action, AnyView, App, AsyncWindowContext, Corner, Entity, EventEmitter, FocusHandle, Focusable,
@@ -26,7 +27,7 @@ use language_model::{
 };
 use notifications::status_toast::{StatusToast, ToastIcon};
 use project::{
-    agent_server_store::{AgentServerStore, CLAUDE_CODE_NAME, GEMINI_NAME},
+    agent_server_store::{AgentServerStore, CLAUDE_CODE_NAME, CODEX_NAME, GEMINI_NAME},
    context_server_store::{ContextServerConfiguration, ContextServerStatus, ContextServerStore},
 };
 use settings::{Settings, SettingsStore, update_settings_file};
@@ -408,7 +409,7 @@ impl AgentConfiguration {

        SwitchField::new(
            "always-allow-tool-actions-switch",
-            "Allow running commands without asking for confirmation",
+            Some("Allow running commands without asking for confirmation"),
            Some(
                "The agent can perform potentially destructive actions without asking for your confirmation.".into(),
            ),
@@ -428,7 +429,7 @@ impl AgentConfiguration {

        SwitchField::new(
            "single-file-review",
-            "Enable single-file agent reviews",
+            Some("Enable single-file agent reviews"),
            Some("Agent edits are also displayed in single-file editors for review.".into()),
            single_file_review,
            move |state, _window, cx| {
@@ -449,7 +450,7 @@ impl AgentConfiguration {

        SwitchField::new(
            "sound-notification",
-            "Play sound when finished generating",
+            Some("Play sound when finished generating"),
            Some(
                "Hear a notification sound when the agent is done generating changes or needs your input.".into(),
            ),
@@ -469,7 +470,7 @@ impl AgentConfiguration {

        SwitchField::new(
            "modifier-send",
-            "Use modifier to submit a message",
+            Some("Use modifier to submit a message"),
            Some(
                "Make a modifier (cmd-enter on macOS, ctrl-enter on Linux or Windows) required to send messages.".into(),
            ),
@@ -1014,7 +1015,9 @@ impl AgentConfiguration {
            .agent_server_store
            .read(cx)
            .external_agents()
-            .filter(|name| name.0 != GEMINI_NAME && name.0 != CLAUDE_CODE_NAME)
+            .filter(|name| {
+                name.0 != GEMINI_NAME && name.0 != CLAUDE_CODE_NAME && name.0 != CODEX_NAME
+            })
            .cloned()
            .collect::<Vec<_>>();

@@ -1077,15 +1080,23 @@ impl AgentConfiguration {
                                .color(Color::Muted),
                            ),
                    )
-                    .child(self.render_agent_server(
-                        IconName::AiGemini,
-                        "Gemini CLI",
-                    ))
-                    .child(Divider::horizontal().color(DividerColor::BorderFaded))
                    .child(self.render_agent_server(
                        IconName::AiClaude,
                        "Claude Code",
                    ))
+                    .child(Divider::horizontal().color(DividerColor::BorderFaded))
+                    .when(cx.has_flag::<CodexAcpFeatureFlag>(), |this| {
+                        this
+                            .child(self.render_agent_server(
+                                IconName::AiOpenAi,
+                                "Codex",
+                            ))
+                            .child(Divider::horizontal().color(DividerColor::BorderFaded))
+                    })
+                    .child(self.render_agent_server(
+                        IconName::AiGemini,
+                        "Gemini CLI",
+                    ))
                    .map(|mut parent| {
                        for agent in user_defined_agents {
                            parent = parent.child(Divider::horizontal().color(DividerColor::BorderFaded))
--- a/crates/agent_ui/src/agent_configuration/add_llm_provider_modal.rs
+++ b/crates/agent_ui/src/agent_configuration/add_llm_provider_modal.rs
@@ -619,10 +619,10 @@ mod tests {
        cx.update(|_window, cx| {
            LanguageModelRegistry::global(cx).update(cx, |registry, cx| {
                registry.register_provider(
-                    FakeLanguageModelProvider::new(
+                    Arc::new(FakeLanguageModelProvider::new(
                        LanguageModelProviderId::new("someprovider"),
                        LanguageModelProviderName::new("Some Provider"),
-                    ),
+                    )),
                    cx,
                );
            });
--- a/crates/agent_ui/src/agent_configuration/manage_profiles_modal.rs
+++ b/crates/agent_ui/src/agent_configuration/manage_profiles_modal.rs
@@ -317,6 +317,8 @@ impl ManageProfilesModal {
        window: &mut Window,
        cx: &mut Context<Self>,
    ) -> impl IntoElement + use<> {
+        let is_focused = profile.navigation.focus_handle.contains_focused(window, cx);
+
        div()
            .id(SharedString::from(format!("profile-{}", profile.id)))
            .track_focus(&profile.navigation.focus_handle)
@@ -328,25 +330,27 @@ impl ManageProfilesModal {
            })
            .child(
                ListItem::new(SharedString::from(format!("profile-{}", profile.id)))
-                    .toggle_state(profile.navigation.focus_handle.contains_focused(window, cx))
+                    .toggle_state(is_focused)
                    .inset(true)
                    .spacing(ListItemSpacing::Sparse)
                    .child(Label::new(profile.name.clone()))
-                    .end_slot(
-                        h_flex()
-                            .gap_1()
-                            .child(
-                                Label::new("Customize")
-                                    .size(LabelSize::Small)
-                                    .color(Color::Muted),
-                            )
-                            .children(KeyBinding::for_action_in(
-                                &menu::Confirm,
-                                &self.focus_handle,
-                                window,
-                                cx,
-                            )),
-                    )
+                    .when(is_focused, |this| {
+                        this.end_slot(
+                            h_flex()
+                                .gap_1()
+                                .child(
+                                    Label::new("Customize")
+                                        .size(LabelSize::Small)
+                                        .color(Color::Muted),
+                                )
+                                .children(KeyBinding::for_action_in(
+                                    &menu::Confirm,
+                                    &self.focus_handle,
+                                    window,
+                                    cx,
+                                )),
+                        )
+                    })
                    .on_click({
                        let profile_id = profile.id.clone();
                        cx.listener(move |this, _, window, cx| {
--- a/crates/agent_ui/src/agent_diff.rs
+++ b/crates/agent_ui/src/agent_diff.rs
@@ -562,10 +562,6 @@ impl Item for AgentDiffPane {
        self.editor.for_each_project_item(cx, f)
    }

-    fn is_singleton(&self, _: &App) -> bool {
-        false
-    }
-
    fn set_nav_history(
        &mut self,
        nav_history: ItemNavHistory,
@@ -850,7 +846,7 @@ fn render_diff_hunk_controls(
                                editor.update(cx, |editor, cx| {
                                    let snapshot = editor.snapshot(window, cx);
                                    let position =
-                                        hunk_range.end.to_point(&snapshot.buffer_snapshot);
+                                        hunk_range.end.to_point(&snapshot.buffer_snapshot());
                                    editor.go_to_hunk_before_or_after_position(
                                        &snapshot,
                                        position,
@@ -886,7 +882,7 @@ fn render_diff_hunk_controls(
                                editor.update(cx, |editor, cx| {
                                    let snapshot = editor.snapshot(window, cx);
                                    let point =
-                                        hunk_range.start.to_point(&snapshot.buffer_snapshot);
+                                        hunk_range.start.to_point(&snapshot.buffer_snapshot());
                                    editor.go_to_hunk_before_or_after_position(
                                        &snapshot,
                                        point,
@@ -1818,7 +1814,6 @@ mod tests {
    use serde_json::json;
    use settings::{Settings, SettingsStore};
    use std::{path::Path, rc::Rc};
-    use theme::ThemeSettings;
    use util::path;

    #[gpui::test]
@@ -1831,7 +1826,7 @@ mod tests {
            AgentSettings::register(cx);
            prompt_store::init(cx);
            workspace::init_settings(cx);
-            ThemeSettings::register(cx);
+            theme::init(theme::LoadThemes::JustBase, cx);
            EditorSettings::register(cx);
            language_model::init_settings(cx);
        });
@@ -1983,7 +1978,7 @@ mod tests {
            AgentSettings::register(cx);
            prompt_store::init(cx);
            workspace::init_settings(cx);
-            ThemeSettings::register(cx);
+            theme::init(theme::LoadThemes::JustBase, cx);
            EditorSettings::register(cx);
            language_model::init_settings(cx);
            workspace::register_project_item::<Editor>(cx);
--- a/crates/agent_ui/src/agent_panel.rs
+++ b/crates/agent_ui/src/agent_panel.rs
@@ -7,7 +7,7 @@ use acp_thread::AcpThread;
 use agent2::{DbThreadMetadata, HistoryEntry};
 use db::kvp::{Dismissable, KEY_VALUE_STORE};
 use project::agent_server_store::{
-    AgentServerCommand, AllAgentServersSettings, CLAUDE_CODE_NAME, GEMINI_NAME,
+    AgentServerCommand, AllAgentServersSettings, CLAUDE_CODE_NAME, CODEX_NAME, GEMINI_NAME,
 };
 use serde::{Deserialize, Serialize};
 use settings::{
@@ -53,7 +53,7 @@ use gpui::{
 };
 use language::LanguageRegistry;
 use language_model::{ConfigurationError, LanguageModelRegistry};
-use project::{DisableAiSettings, Project, ProjectPath, Worktree};
+use project::{Project, ProjectPath, Worktree};
 use prompt_store::{PromptBuilder, PromptStore, UserPromptId};
 use rules_library::{RulesLibrary, open_rules_library};
 use search::{BufferSearchBar, buffer_search};
@@ -75,6 +75,7 @@ use zed_actions::{
    assistant::{OpenRulesLibrary, ToggleFocus},
 };

+use feature_flags::{CodexAcpFeatureFlag, FeatureFlagAppExt as _};
 const AGENT_PANEL_KEY: &str = "agent_panel";

 #[derive(Serialize, Deserialize, Debug)]
@@ -216,6 +217,7 @@ pub enum AgentType {
    TextThread,
    Gemini,
    ClaudeCode,
+    Codex,
    NativeAgent,
    Custom {
        name: SharedString,
@@ -230,6 +232,7 @@ impl AgentType {
            Self::NativeAgent => "Agent 2".into(),
            Self::Gemini => "Gemini CLI".into(),
            Self::ClaudeCode => "Claude Code".into(),
+            Self::Codex => "Codex".into(),
            Self::Custom { name, .. } => name.into(),
        }
    }
@@ -239,6 +242,7 @@ impl AgentType {
            Self::Zed | Self::NativeAgent | Self::TextThread => None,
            Self::Gemini => Some(IconName::AiGemini),
            Self::ClaudeCode => Some(IconName::AiClaude),
+            Self::Codex => Some(IconName::AiOpenAi),
            Self::Custom { .. } => Some(IconName::Terminal),
        }
    }
@@ -249,6 +253,7 @@ impl From<ExternalAgent> for AgentType {
        match value {
            ExternalAgent::Gemini => Self::Gemini,
            ExternalAgent::ClaudeCode => Self::ClaudeCode,
+            ExternalAgent::Codex => Self::Codex,
            ExternalAgent::Custom { name, command } => Self::Custom { name, command },
            ExternalAgent::NativeAgent => Self::NativeAgent,
        }
@@ -514,6 +519,7 @@ impl AgentPanel {
                        cx,
                    )
                });
+
                panel.as_mut(cx).loading = true;
                if let Some(serialized_panel) = serialized_panel {
                    panel.update(cx, |panel, cx| {
@@ -665,43 +671,6 @@ impl AgentPanel {
            )
        });

-        let mut old_disable_ai = false;
-        cx.observe_global_in::<SettingsStore>(window, move |panel, window, cx| {
-            let disable_ai = DisableAiSettings::get_global(cx).disable_ai;
-            if old_disable_ai != disable_ai {
-                let agent_panel_id = cx.entity_id();
-                let agent_panel_visible = panel
-                    .workspace
-                    .update(cx, |workspace, cx| {
-                        let agent_dock_position = panel.position(window, cx);
-                        let agent_dock = workspace.dock_at_position(agent_dock_position);
-                        let agent_panel_focused = agent_dock
-                            .read(cx)
-                            .active_panel()
-                            .is_some_and(|panel| panel.panel_id() == agent_panel_id);
-
-                        let active_panel_visible = agent_dock
-                            .read(cx)
-                            .visible_panel()
-                            .is_some_and(|panel| panel.panel_id() == agent_panel_id);
-
-                        if agent_panel_focused {
-                            cx.dispatch_action(&ToggleFocus);
-                        }
-
-                        active_panel_visible
-                    })
-                    .unwrap_or_default();
-
-                if agent_panel_visible {
-                    cx.emit(PanelEvent::Close);
-                }
-
-                old_disable_ai = disable_ai;
-            }
-        })
-        .detach();
-
        Self {
            active_view,
            workspace,
@@ -1103,15 +1072,15 @@ impl AgentPanel {
            WhichFontSize::AgentFont => {
                if persist {
                    update_settings_file(self.fs.clone(), cx, move |settings, cx| {
-                        let agent_font_size =
-                            ThemeSettings::get_global(cx).agent_font_size(cx) + delta;
+                        let agent_ui_font_size =
+                            ThemeSettings::get_global(cx).agent_ui_font_size(cx) + delta;
                        let _ = settings
                            .theme
-                            .agent_font_size
-                            .insert(theme::clamp_font_size(agent_font_size).into());
+                            .agent_ui_font_size
+                            .insert(theme::clamp_font_size(agent_ui_font_size).into());
                    });
                } else {
-                    theme::adjust_agent_font_size(cx, |size| size + delta);
+                    theme::adjust_agent_ui_font_size(cx, |size| size + delta);
                }
            }
            WhichFontSize::BufferFont => {
@@ -1131,10 +1100,10 @@ impl AgentPanel {
    ) {
        if action.persist {
            update_settings_file(self.fs.clone(), cx, move |settings, _| {
-                settings.theme.agent_font_size = None;
+                settings.theme.agent_ui_font_size = None;
            });
        } else {
-            theme::reset_agent_font_size(cx);
+            theme::reset_agent_ui_font_size(cx);
        }
    }

@@ -1427,6 +1396,11 @@ impl AgentPanel {
                    cx,
                )
            }
+            AgentType::Codex => {
+                self.selected_agent = AgentType::Codex;
+                self.serialize(cx);
+                self.external_thread(Some(crate::ExternalAgent::Codex), None, None, window, cx)
+            }
            AgentType::Custom { name, command } => self.external_thread(
                Some(crate::ExternalAgent::Custom { name, command }),
                None,
@@ -1939,32 +1913,6 @@ impl AgentPanel {
                            )
                            .separator()
                            .header("External Agents")
-                            .item(
-                                ContextMenuEntry::new("New Gemini CLI Thread")
-                                    .icon(IconName::AiGemini)
-                                    .icon_color(Color::Muted)
-                                    .disabled(is_via_collab)
-                                    .handler({
-                                        let workspace = workspace.clone();
-                                        move |window, cx| {
-                                            if let Some(workspace) = workspace.upgrade() {
-                                                workspace.update(cx, |workspace, cx| {
-                                                    if let Some(panel) =
-                                                        workspace.panel::<AgentPanel>(cx)
-                                                    {
-                                                        panel.update(cx, |panel, cx| {
-                                                            panel.new_agent_thread(
-                                                                AgentType::Gemini,
-                                                                window,
-                                                                cx,
-                                                            );
-                                                        });
-                                                    }
-                                                });
-                                            }
-                                        }
-                                    }),
-                            )
                            .item(
                                ContextMenuEntry::new("New Claude Code Thread")
                                    .icon(IconName::AiClaude)
@@ -1991,12 +1939,66 @@ impl AgentPanel {
                                        }
                                    }),
                            )
+                            .when(cx.has_flag::<CodexAcpFeatureFlag>(), |this| {
+                                this.item(
+                                    ContextMenuEntry::new("New Codex Thread")
+                                        .icon(IconName::AiOpenAi)
+                                        .disabled(is_via_collab)
+                                        .icon_color(Color::Muted)
+                                        .handler({
+                                            let workspace = workspace.clone();
+                                            move |window, cx| {
+                                                if let Some(workspace) = workspace.upgrade() {
+                                                    workspace.update(cx, |workspace, cx| {
+                                                        if let Some(panel) =
+                                                            workspace.panel::<AgentPanel>(cx)
+                                                        {
+                                                            panel.update(cx, |panel, cx| {
+                                                                panel.new_agent_thread(
+                                                                    AgentType::Codex,
+                                                                    window,
+                                                                    cx,
+                                                                );
+                                                            });
+                                                        }
+                                                    });
+                                                }
+                                            }
+                                        }),
+                                )
+                            })
+                            .item(
+                                ContextMenuEntry::new("New Gemini CLI Thread")
+                                    .icon(IconName::AiGemini)
+                                    .icon_color(Color::Muted)
+                                    .disabled(is_via_collab)
+                                    .handler({
+                                        let workspace = workspace.clone();
+                                        move |window, cx| {
+                                            if let Some(workspace) = workspace.upgrade() {
+                                                workspace.update(cx, |workspace, cx| {
+                                                    if let Some(panel) =
+                                                        workspace.panel::<AgentPanel>(cx)
+                                                    {
+                                                        panel.update(cx, |panel, cx| {
+                                                            panel.new_agent_thread(
+                                                                AgentType::Gemini,
+                                                                window,
+                                                                cx,
+                                                            );
+                                                        });
+                                                    }
+                                                });
+                                            }
+                                        }
+                                    }),
+                            )
                            .map(|mut menu| {
                                let agent_names = agent_server_store
                                    .read(cx)
                                    .external_agents()
                                    .filter(|name| {
-                                        name.0 != GEMINI_NAME && name.0 != CLAUDE_CODE_NAME
+                                        name.0 != GEMINI_NAME && name.0 != CLAUDE_CODE_NAME && name.0 != CODEX_NAME
                                    })
                                    .cloned()
                                    .collect::<Vec<_>>();
@@ -2532,7 +2534,7 @@ impl Render for AgentPanel {

        match self.active_view.which_font_size_used() {
            WhichFontSize::AgentFont => {
-                WithRemSize::new(ThemeSettings::get_global(cx).agent_font_size(cx))
+                WithRemSize::new(ThemeSettings::get_global(cx).agent_ui_font_size(cx))
                    .size_full()
                    .child(content)
                    .into_any()
--- a/crates/agent_ui/src/agent_ui.rs
+++ b/crates/agent_ui/src/agent_ui.rs
@@ -167,6 +167,7 @@ enum ExternalAgent {
    #[default]
    Gemini,
    ClaudeCode,
+    Codex,
    NativeAgent,
    Custom {
        name: SharedString,
@@ -188,6 +189,7 @@ impl ExternalAgent {
            Self::NativeAgent => "zed",
            Self::Gemini => "gemini-cli",
            Self::ClaudeCode => "claude-code",
+            Self::Codex => "codex",
            Self::Custom { .. } => "custom",
        }
    }
@@ -200,6 +202,7 @@ impl ExternalAgent {
        match self {
            Self::Gemini => Rc::new(agent_servers::Gemini),
            Self::ClaudeCode => Rc::new(agent_servers::ClaudeCode),
+            Self::Codex => Rc::new(agent_servers::Codex),
            Self::NativeAgent => Rc::new(agent2::NativeAgentServer::new(fs, history)),
            Self::Custom { name, command: _ } => {
                Rc::new(agent_servers::CustomAgentServer::new(name.clone()))
--- a/crates/agent_ui/src/inline_assistant.rs
+++ b/crates/agent_ui/src/inline_assistant.rs
@@ -18,7 +18,9 @@ use agent_settings::AgentSettings;
 use anyhow::{Context as _, Result};
 use client::telemetry::Telemetry;
 use collections::{HashMap, HashSet, VecDeque, hash_map};
+use editor::RowExt;
 use editor::SelectionEffects;
+use editor::scroll::ScrollOffset;
 use editor::{
    Anchor, AnchorRangeExt, CodeActionProvider, Editor, EditorEvent, ExcerptId, ExcerptRange,
    MultiBuffer, MultiBufferSnapshot, ToOffset as _, ToPoint,
@@ -380,7 +382,7 @@ impl InlineAssistant {
        if let Some(editor_assists) = self.assists_by_editor.get(&editor.downgrade()) {
            for assist_id in &editor_assists.assist_ids {
                let assist = &self.assists[assist_id];
-                let range = assist.range.to_point(&snapshot.buffer_snapshot);
+                let range = assist.range.to_point(&snapshot.buffer_snapshot());
                if range.start.row <= newest_selection.start.row
                    && newest_selection.end.row <= range.end.row
                {
@@ -400,16 +402,16 @@ impl InlineAssistant {
                    selection.end.row -= 1;
                }
                selection.end.column = snapshot
-                    .buffer_snapshot
+                    .buffer_snapshot()
                    .line_len(MultiBufferRow(selection.end.row));
            } else if let Some(fold) =
                snapshot.crease_for_buffer_row(MultiBufferRow(selection.end.row))
            {
                selection.start = fold.range().start;
                selection.end = fold.range().end;
-                if MultiBufferRow(selection.end.row) < snapshot.buffer_snapshot.max_row() {
+                if MultiBufferRow(selection.end.row) < snapshot.buffer_snapshot().max_row() {
                    let chars = snapshot
-                        .buffer_snapshot
+                        .buffer_snapshot()
                        .chars_at(Point::new(selection.end.row + 1, 0));

                    for c in chars {
@@ -425,7 +427,7 @@ impl InlineAssistant {
                        {
                            selection.end.row += 1;
                            selection.end.column = snapshot
-                                .buffer_snapshot
+                                .buffer_snapshot()
                                .line_len(MultiBufferRow(selection.end.row));
                        }
                    }
@@ -445,7 +447,7 @@ impl InlineAssistant {
            }
            selections.push(selection);
        }
-        let snapshot = &snapshot.buffer_snapshot;
+        let snapshot = &snapshot.buffer_snapshot();
        let newest_selection = newest_selection.unwrap();

        let mut codegen_ranges = Vec::new();
@@ -744,7 +746,7 @@ impl InlineAssistant {
                let scroll_bottom = scroll_top + editor.visible_line_count().unwrap_or(0.);
                editor_assists.scroll_lock = editor
                    .row_for_block(decorations.prompt_block_id, cx)
-                    .map(|row| row.0 as f32)
+                    .map(|row| row.as_f64())
                    .filter(|prompt_row| (scroll_top..scroll_bottom).contains(&prompt_row))
                    .map(|prompt_row| InlineAssistScrollLock {
                        assist_id,
@@ -910,7 +912,9 @@ impl InlineAssistant {

        editor.update(cx, |editor, cx| {
            let scroll_position = editor.scroll_position(cx);
-            let target_scroll_top = editor.row_for_block(decorations.prompt_block_id, cx)?.0 as f32
+            let target_scroll_top = editor
+                .row_for_block(decorations.prompt_block_id, cx)?
+                .as_f64()
                - scroll_lock.distance_from_top;
            if target_scroll_top != scroll_position.y {
                editor.set_scroll_position(point(scroll_position.x, target_scroll_top), window, cx);
@@ -959,8 +963,9 @@ impl InlineAssistant {
                    if let Some(decorations) = assist.decorations.as_ref() {
                        let distance_from_top = editor.update(cx, |editor, cx| {
                            let scroll_top = editor.scroll_position(cx).y;
-                            let prompt_row =
-                                editor.row_for_block(decorations.prompt_block_id, cx)?.0 as f32;
+                            let prompt_row = editor
+                                .row_for_block(decorations.prompt_block_id, cx)?
+                                .0 as ScrollOffset;
                            Some(prompt_row - scroll_top)
                        });

@@ -1192,8 +1197,8 @@ impl InlineAssistant {
            let mut scroll_target_range = None;
            if let Some(decorations) = assist.decorations.as_ref() {
                scroll_target_range = maybe!({
-                    let top = editor.row_for_block(decorations.prompt_block_id, cx)?.0 as f32;
-                    let bottom = editor.row_for_block(decorations.end_block_id, cx)?.0 as f32;
+                    let top = editor.row_for_block(decorations.prompt_block_id, cx)?.0 as f64;
+                    let bottom = editor.row_for_block(decorations.end_block_id, cx)?.0 as f64;
                    Some((top, bottom))
                });
                if scroll_target_range.is_none() {
@@ -1207,15 +1212,15 @@ impl InlineAssistant {
                    .start
                    .to_display_point(&snapshot.display_snapshot)
                    .row();
-                let top = start_row.0 as f32;
+                let top = start_row.0 as ScrollOffset;
                let bottom = top + 1.0;
                (top, bottom)
            });
            let mut scroll_target_top = scroll_target_range.0;
            let mut scroll_target_bottom = scroll_target_range.1;

-            scroll_target_top -= editor.vertical_scroll_margin() as f32;
-            scroll_target_bottom += editor.vertical_scroll_margin() as f32;
+            scroll_target_top -= editor.vertical_scroll_margin() as ScrollOffset;
+            scroll_target_bottom += editor.vertical_scroll_margin() as ScrollOffset;

            let height_in_lines = editor.visible_line_count().unwrap_or(0.);
            let scroll_top = editor.scroll_position(cx).y;
@@ -1543,7 +1548,7 @@ struct EditorInlineAssists {

 struct InlineAssistScrollLock {
    assist_id: InlineAssistId,
-    distance_from_top: f32,
+    distance_from_top: ScrollOffset,
 }

 impl EditorInlineAssists {
--- a/crates/agent_ui/src/profile_selector.rs
+++ b/crates/agent_ui/src/profile_selector.rs
@@ -3,12 +3,20 @@ use agent_settings::{
    AgentProfile, AgentProfileId, AgentSettings, AvailableProfiles, builtin_profiles,
 };
 use fs::Fs;
-use gpui::{Action, Entity, FocusHandle, Subscription, prelude::*};
-use settings::{DockPosition, Settings as _, SettingsStore, update_settings_file};
-use std::sync::Arc;
+use fuzzy::{StringMatch, StringMatchCandidate, match_strings};
+use gpui::{
+    Action, AnyElement, App, BackgroundExecutor, Context, DismissEvent, Entity, FocusHandle,
+    Focusable, SharedString, Subscription, Task, Window,
+};
+use picker::{Picker, PickerDelegate, popover_menu::PickerPopoverMenu};
+use settings::{Settings as _, SettingsStore, update_settings_file};
+use std::{
+    sync::atomic::Ordering,
+    sync::{Arc, atomic::AtomicBool},
+};
 use ui::{
-    ContextMenu, ContextMenuEntry, DocumentationEdge, DocumentationSide, PopoverMenu,
-    PopoverMenuHandle, TintColor, Tooltip, prelude::*,
+    DocumentationAside, DocumentationEdge, DocumentationSide, HighlightedLabel, LabelSize,
+    ListItem, ListItemSpacing, PopoverMenuHandle, TintColor, Tooltip, prelude::*,
 };

 /// Trait for types that can provide and manage agent profiles
@@ -25,9 +33,11 @@ pub trait ProfileProvider {

 pub struct ProfileSelector {
    profiles: AvailableProfiles,
+    pending_refresh: bool,
    fs: Arc<dyn Fs>,
    provider: Arc<dyn ProfileProvider>,
-    menu_handle: PopoverMenuHandle<ContextMenu>,
+    picker: Option<Entity<Picker<ProfilePickerDelegate>>>,
+    picker_handle: PopoverMenuHandle<Picker<ProfilePickerDelegate>>,
    focus_handle: FocusHandle,
    _subscriptions: Vec<Subscription>,
 }
@@ -40,125 +50,91 @@ impl ProfileSelector {
        cx: &mut Context<Self>,
    ) -> Self {
        let settings_subscription = cx.observe_global::<SettingsStore>(move |this, cx| {
-            this.refresh_profiles(cx);
+            this.pending_refresh = true;
+            cx.notify();
        });

        Self {
            profiles: AgentProfile::available_profiles(cx),
+            pending_refresh: false,
            fs,
            provider,
-            menu_handle: PopoverMenuHandle::default(),
+            picker: None,
+            picker_handle: PopoverMenuHandle::default(),
            focus_handle,
            _subscriptions: vec![settings_subscription],
        }
    }

-    pub fn menu_handle(&self) -> PopoverMenuHandle<ContextMenu> {
-        self.menu_handle.clone()
+    pub fn menu_handle(&self) -> PopoverMenuHandle<Picker<ProfilePickerDelegate>> {
+        self.picker_handle.clone()
    }

-    fn refresh_profiles(&mut self, cx: &mut Context<Self>) {
-        self.profiles = AgentProfile::available_profiles(cx);
-    }
-
-    fn build_context_menu(
-        &self,
+    fn ensure_picker(
+        &mut self,
        window: &mut Window,
        cx: &mut Context<Self>,
-    ) -> Entity<ContextMenu> {
-        ContextMenu::build(window, cx, |mut menu, _window, cx| {
-            let settings = AgentSettings::get_global(cx);
+    ) -> Entity<Picker<ProfilePickerDelegate>> {
+        if self.picker.is_none() {
+            let delegate = ProfilePickerDelegate::new(
+                self.fs.clone(),
+                self.provider.clone(),
+                self.profiles.clone(),
+                cx.background_executor().clone(),
+                cx,
+            );

-            let mut found_non_builtin = false;
-            for (profile_id, profile_name) in self.profiles.iter() {
-                if !builtin_profiles::is_builtin(profile_id) {
-                    found_non_builtin = true;
-                    continue;
-                }
-                menu = menu.item(self.menu_entry_for_profile(
-                    profile_id.clone(),
-                    profile_name,
-                    settings,
-                    cx,
-                ));
-            }
+            let picker = cx.new(|cx| {
+                Picker::list(delegate, window, cx)
+                    .show_scrollbar(true)
+                    .width(rems(18.))
+                    .max_height(Some(rems(20.).into()))
+            });

-            if found_non_builtin {
-                menu = menu.separator().header("Custom Profiles");
-                for (profile_id, profile_name) in self.profiles.iter() {
-                    if builtin_profiles::is_builtin(profile_id) {
-                        continue;
-                    }
-                    menu = menu.item(self.menu_entry_for_profile(
-                        profile_id.clone(),
-                        profile_name,
-                        settings,
-                        cx,
-                    ));
-                }
-            }
+            self.picker = Some(picker);
+        }

-            menu = menu.separator();
-            menu = menu.item(ContextMenuEntry::new("Configure Profiles…").handler(
-                move |window, cx| {
-                    window.dispatch_action(ManageProfiles::default().boxed_clone(), cx);
-                },
-            ));
-
-            menu
-        })
-    }
-
-    fn menu_entry_for_profile(
-        &self,
-        profile_id: AgentProfileId,
-        profile_name: &SharedString,
-        settings: &AgentSettings,
-        cx: &App,
-    ) -> ContextMenuEntry {
-        let documentation = match profile_name.to_lowercase().as_str() {
-            builtin_profiles::WRITE => Some("Get help to write anything."),
-            builtin_profiles::ASK => Some("Chat about your codebase."),
-            builtin_profiles::MINIMAL => Some("Chat about anything with no tools."),
-            _ => None,
-        };
-        let thread_profile_id = self.provider.profile_id(cx);
-
-        let entry = ContextMenuEntry::new(profile_name.clone())
-            .toggleable(IconPosition::End, profile_id == thread_profile_id);
-
-        let entry = if let Some(doc_text) = documentation {
-            entry.documentation_aside(
-                documentation_side(settings.dock),
-                DocumentationEdge::Top,
-                move |_| Label::new(doc_text).into_any_element(),
-            )
-        } else {
-            entry
-        };
-
-        entry.handler({
-            let fs = self.fs.clone();
-            let provider = self.provider.clone();
-            move |_window, cx| {
-                update_settings_file(fs.clone(), cx, {
-                    let profile_id = profile_id.clone();
-                    move |settings, _cx| {
-                        settings
-                            .agent
-                            .get_or_insert_default()
-                            .set_profile(profile_id.0);
-                    }
+        if self.pending_refresh {
+            if let Some(picker) = &self.picker {
+                let profiles = AgentProfile::available_profiles(cx);
+                self.profiles = profiles.clone();
+                picker.update(cx, |picker, cx| {
+                    let query = picker.query(cx);
+                    picker
+                        .delegate
+                        .refresh_profiles(profiles.clone(), query, cx);
                });
-
-                provider.set_profile(profile_id.clone(), cx);
            }
-        })
+            self.pending_refresh = false;
+        }
+
+        self.picker.as_ref().unwrap().clone()
+    }
+}
+
+impl Focusable for ProfileSelector {
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        if let Some(picker) = &self.picker {
+            picker.focus_handle(cx)
+        } else {
+            self.focus_handle.clone()
+        }
    }
 }

 impl Render for ProfileSelector {
-    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        if !self.provider.profiles_supported(cx) {
+            return Button::new("tools-not-supported-button", "Tools Unsupported")
+                .disabled(true)
+                .label_size(LabelSize::Small)
+                .color(Color::Muted)
+                .tooltip(Tooltip::text("This model does not support tools."))
+                .into_any_element();
+        }
+
+        let picker = self.ensure_picker(window, cx);
+
        let settings = AgentSettings::get_global(cx);
        let profile_id = self.provider.profile_id(cx);
        let profile = settings.profiles.get(&profile_id);
@@ -166,62 +142,594 @@ impl Render for ProfileSelector {
        let selected_profile = profile
            .map(|profile| profile.name.clone())
            .unwrap_or_else(|| "Unknown".into());
+        let focus_handle = self.focus_handle.clone();

-        if self.provider.profiles_supported(cx) {
-            let this = cx.entity();
-            let focus_handle = self.focus_handle.clone();
-            let trigger_button = Button::new("profile-selector-model", selected_profile)
-                .label_size(LabelSize::Small)
-                .color(Color::Muted)
-                .icon(IconName::ChevronDown)
-                .icon_size(IconSize::XSmall)
-                .icon_position(IconPosition::End)
-                .icon_color(Color::Muted)
-                .selected_style(ButtonStyle::Tinted(TintColor::Accent));
+        let trigger_button = Button::new("profile-selector", selected_profile)
+            .label_size(LabelSize::Small)
+            .color(Color::Muted)
+            .icon(IconName::ChevronDown)
+            .icon_size(IconSize::XSmall)
+            .icon_position(IconPosition::End)
+            .icon_color(Color::Muted)
+            .selected_style(ButtonStyle::Tinted(TintColor::Accent));

-            PopoverMenu::new("profile-selector")
-                .trigger_with_tooltip(trigger_button, {
-                    move |window, cx| {
-                        Tooltip::for_action_in(
-                            "Toggle Profile Menu",
-                            &ToggleProfileSelector,
-                            &focus_handle,
-                            window,
-                            cx,
-                        )
-                    }
-                })
-                .anchor(
-                    if documentation_side(settings.dock) == DocumentationSide::Left {
-                        gpui::Corner::BottomRight
-                    } else {
-                        gpui::Corner::BottomLeft
-                    },
+        PickerPopoverMenu::new(
+            picker,
+            trigger_button,
+            move |window, cx| {
+                Tooltip::for_action_in(
+                    "Toggle Profile Menu",
+                    &ToggleProfileSelector,
+                    &focus_handle,
+                    window,
+                    cx,
                )
-                .with_handle(self.menu_handle.clone())
-                .menu(move |window, cx| {
-                    Some(this.update(cx, |this, cx| this.build_context_menu(window, cx)))
-                })
-                .offset(gpui::Point {
-                    x: px(0.0),
-                    y: px(-2.0),
-                })
-                .into_any_element()
+            },
+            gpui::Corner::BottomRight,
+            cx,
+        )
+        .with_handle(self.picker_handle.clone())
+        .render(window, cx)
+        .into_any_element()
+    }
+}
+
+#[derive(Clone)]
+struct ProfileCandidate {
+    id: AgentProfileId,
+    name: SharedString,
+    is_builtin: bool,
+}
+
+#[derive(Clone)]
+struct ProfileMatchEntry {
+    candidate_index: usize,
+    positions: Vec<usize>,
+}
+
+enum ProfilePickerEntry {
+    Header(SharedString),
+    Profile(ProfileMatchEntry),
+}
+
+pub(crate) struct ProfilePickerDelegate {
+    fs: Arc<dyn Fs>,
+    provider: Arc<dyn ProfileProvider>,
+    background: BackgroundExecutor,
+    candidates: Vec<ProfileCandidate>,
+    string_candidates: Arc<Vec<StringMatchCandidate>>,
+    filtered_entries: Vec<ProfilePickerEntry>,
+    selected_index: usize,
+    query: String,
+    cancel: Option<Arc<AtomicBool>>,
+}
+
+impl ProfilePickerDelegate {
+    fn new(
+        fs: Arc<dyn Fs>,
+        provider: Arc<dyn ProfileProvider>,
+        profiles: AvailableProfiles,
+        background: BackgroundExecutor,
+        cx: &mut Context<ProfileSelector>,
+    ) -> Self {
+        let candidates = Self::candidates_from(profiles);
+        let string_candidates = Arc::new(Self::string_candidates(&candidates));
+        let filtered_entries = Self::entries_from_candidates(&candidates);
+
+        let mut this = Self {
+            fs,
+            provider,
+            background,
+            candidates,
+            string_candidates,
+            filtered_entries,
+            selected_index: 0,
+            query: String::new(),
+            cancel: None,
+        };
+
+        this.selected_index = this
+            .index_of_profile(&this.provider.profile_id(cx))
+            .unwrap_or_else(|| this.first_selectable_index().unwrap_or(0));
+
+        this
+    }
+
+    fn refresh_profiles(
+        &mut self,
+        profiles: AvailableProfiles,
+        query: String,
+        cx: &mut Context<Picker<Self>>,
+    ) {
+        self.candidates = Self::candidates_from(profiles);
+        self.string_candidates = Arc::new(Self::string_candidates(&self.candidates));
+        self.query = query;
+
+        if self.query.is_empty() {
+            self.filtered_entries = Self::entries_from_candidates(&self.candidates);
        } else {
-            Button::new("tools-not-supported-button", "Tools Unsupported")
-                .disabled(true)
-                .label_size(LabelSize::Small)
-                .color(Color::Muted)
-                .tooltip(Tooltip::text("This model does not support tools."))
-                .into_any_element()
+            let matches = self.search_blocking(&self.query);
+            self.filtered_entries = self.entries_from_matches(matches);
+        }
+
+        self.selected_index = self
+            .index_of_profile(&self.provider.profile_id(cx))
+            .unwrap_or_else(|| self.first_selectable_index().unwrap_or(0));
+        cx.notify();
+    }
+
+    fn candidates_from(profiles: AvailableProfiles) -> Vec<ProfileCandidate> {
+        profiles
+            .into_iter()
+            .map(|(id, name)| ProfileCandidate {
+                is_builtin: builtin_profiles::is_builtin(&id),
+                id,
+                name,
+            })
+            .collect()
+    }
+
+    fn string_candidates(candidates: &[ProfileCandidate]) -> Vec<StringMatchCandidate> {
+        candidates
+            .iter()
+            .enumerate()
+            .map(|(index, candidate)| StringMatchCandidate::new(index, candidate.name.as_ref()))
+            .collect()
+    }
+
+    fn documentation(candidate: &ProfileCandidate) -> Option<&'static str> {
+        match candidate.id.as_str() {
+            builtin_profiles::WRITE => Some("Get help to write anything."),
+            builtin_profiles::ASK => Some("Chat about your codebase."),
+            builtin_profiles::MINIMAL => Some("Chat about anything with no tools."),
+            _ => None,
+        }
+    }
+
+    fn entries_from_candidates(candidates: &[ProfileCandidate]) -> Vec<ProfilePickerEntry> {
+        let mut entries = Vec::new();
+        let mut inserted_custom_header = false;
+
+        for (idx, candidate) in candidates.iter().enumerate() {
+            if !candidate.is_builtin && !inserted_custom_header {
+                if !entries.is_empty() {
+                    entries.push(ProfilePickerEntry::Header("Custom Profiles".into()));
+                }
+                inserted_custom_header = true;
+            }
+
+            entries.push(ProfilePickerEntry::Profile(ProfileMatchEntry {
+                candidate_index: idx,
+                positions: Vec::new(),
+            }));
+        }
+
+        entries
+    }
+
+    fn entries_from_matches(&self, matches: Vec<StringMatch>) -> Vec<ProfilePickerEntry> {
+        let mut entries = Vec::new();
+        for mat in matches {
+            if self.candidates.get(mat.candidate_id).is_some() {
+                entries.push(ProfilePickerEntry::Profile(ProfileMatchEntry {
+                    candidate_index: mat.candidate_id,
+                    positions: mat.positions,
+                }));
+            }
+        }
+        entries
+    }
+
+    fn first_selectable_index(&self) -> Option<usize> {
+        self.filtered_entries
+            .iter()
+            .position(|entry| matches!(entry, ProfilePickerEntry::Profile(_)))
+    }
+
+    fn index_of_profile(&self, profile_id: &AgentProfileId) -> Option<usize> {
+        self.filtered_entries.iter().position(|entry| {
+            matches!(entry, ProfilePickerEntry::Profile(profile) if self
+                .candidates
+                .get(profile.candidate_index)
+                .map(|candidate| &candidate.id == profile_id)
+                .unwrap_or(false))
+        })
+    }
+
+    fn search_blocking(&self, query: &str) -> Vec<StringMatch> {
+        if query.is_empty() {
+            return self
+                .string_candidates
+                .iter()
+                .map(|candidate| StringMatch {
+                    candidate_id: candidate.id,
+                    score: 0.0,
+                    positions: Vec::new(),
+                    string: candidate.string.clone(),
+                })
+                .collect();
+        }
+
+        let cancel_flag = AtomicBool::new(false);
+
+        self.background.block(match_strings(
+            self.string_candidates.as_ref(),
+            query,
+            false,
+            true,
+            100,
+            &cancel_flag,
+            self.background.clone(),
+        ))
+    }
+}
+
+impl PickerDelegate for ProfilePickerDelegate {
+    type ListItem = AnyElement;
+
+    fn placeholder_text(&self, _: &mut Window, _: &mut App) -> Arc<str> {
+        "Search profiles…".into()
+    }
+
+    fn no_matches_text(&self, _window: &mut Window, _cx: &mut App) -> Option<SharedString> {
+        let text = if self.candidates.is_empty() {
+            "No profiles.".into()
+        } else {
+            "No profiles match your search.".into()
+        };
+        Some(text)
+    }
+
+    fn match_count(&self) -> usize {
+        self.filtered_entries.len()
+    }
+
+    fn selected_index(&self) -> usize {
+        self.selected_index
+    }
+
+    fn set_selected_index(&mut self, ix: usize, _: &mut Window, cx: &mut Context<Picker<Self>>) {
+        self.selected_index = ix.min(self.filtered_entries.len().saturating_sub(1));
+        cx.notify();
+    }
+
+    fn can_select(
+        &mut self,
+        ix: usize,
+        _window: &mut Window,
+        _cx: &mut Context<Picker<Self>>,
+    ) -> bool {
+        match self.filtered_entries.get(ix) {
+            Some(ProfilePickerEntry::Profile(_)) => true,
+            Some(ProfilePickerEntry::Header(_)) | None => false,
+        }
+    }
+
+    fn update_matches(
+        &mut self,
+        query: String,
+        window: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> Task<()> {
+        if query.is_empty() {
+            self.query.clear();
+            self.filtered_entries = Self::entries_from_candidates(&self.candidates);
+            self.selected_index = self
+                .index_of_profile(&self.provider.profile_id(cx))
+                .unwrap_or_else(|| self.first_selectable_index().unwrap_or(0));
+            cx.notify();
+            return Task::ready(());
+        }
+
+        if let Some(prev) = &self.cancel {
+            prev.store(true, Ordering::Relaxed);
+        }
+        let cancel = Arc::new(AtomicBool::new(false));
+        self.cancel = Some(cancel.clone());
+
+        let string_candidates = self.string_candidates.clone();
+        let background = self.background.clone();
+        let provider = self.provider.clone();
+        self.query = query.clone();
+
+        let cancel_for_future = cancel;
+
+        cx.spawn_in(window, async move |this, cx| {
+            let matches = match_strings(
+                string_candidates.as_ref(),
+                &query,
+                false,
+                true,
+                100,
+                cancel_for_future.as_ref(),
+                background,
+            )
+            .await;
+
+            this.update_in(cx, |this, _, cx| {
+                if this.delegate.query != query {
+                    return;
+                }
+
+                this.delegate.filtered_entries = this.delegate.entries_from_matches(matches);
+                this.delegate.selected_index = this
+                    .delegate
+                    .index_of_profile(&provider.profile_id(cx))
+                    .unwrap_or_else(|| this.delegate.first_selectable_index().unwrap_or(0));
+                cx.notify();
+            })
+            .ok();
+        })
+    }
+
+    fn confirm(&mut self, _: bool, _window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        match self.filtered_entries.get(self.selected_index) {
+            Some(ProfilePickerEntry::Profile(entry)) => {
+                if let Some(candidate) = self.candidates.get(entry.candidate_index) {
+                    let profile_id = candidate.id.clone();
+                    let fs = self.fs.clone();
+                    let provider = self.provider.clone();
+
+                    update_settings_file(fs, cx, {
+                        let profile_id = profile_id.clone();
+                        move |settings, _cx| {
+                            settings
+                                .agent
+                                .get_or_insert_default()
+                                .set_profile(profile_id.0);
+                        }
+                    });
+
+                    provider.set_profile(profile_id.clone(), cx);
+
+                    telemetry::event!(
+                        "agent_profile_switched",
+                        profile_id = profile_id.as_str(),
+                        source = "picker"
+                    );
+                }
+
+                cx.emit(DismissEvent);
+            }
+            _ => {}
+        }
+    }
+
+    fn dismissed(&mut self, window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        cx.defer_in(window, |picker, window, cx| {
+            picker.set_query("", window, cx);
+        });
+        cx.emit(DismissEvent);
+    }
+
+    fn render_match(
+        &self,
+        ix: usize,
+        selected: bool,
+        _: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> Option<Self::ListItem> {
+        match self.filtered_entries.get(ix)? {
+            ProfilePickerEntry::Header(label) => Some(
+                div()
+                    .px_2p5()
+                    .pb_0p5()
+                    .when(ix > 0, |this| {
+                        this.mt_1p5()
+                            .pt_2()
+                            .border_t_1()
+                            .border_color(cx.theme().colors().border_variant)
+                    })
+                    .child(
+                        Label::new(label.clone())
+                            .size(LabelSize::XSmall)
+                            .color(Color::Muted),
+                    )
+                    .into_any_element(),
+            ),
+            ProfilePickerEntry::Profile(entry) => {
+                let candidate = self.candidates.get(entry.candidate_index)?;
+                let active_id = self.provider.profile_id(cx);
+                let is_active = active_id == candidate.id;
+
+                Some(
+                    ListItem::new(SharedString::from(candidate.id.0.clone()))
+                        .inset(true)
+                        .spacing(ListItemSpacing::Sparse)
+                        .toggle_state(selected)
+                        .child(HighlightedLabel::new(
+                            candidate.name.clone(),
+                            entry.positions.clone(),
+                        ))
+                        .when(is_active, |this| {
+                            this.end_slot(
+                                div()
+                                    .pr_2()
+                                    .child(Icon::new(IconName::Check).color(Color::Accent)),
+                            )
+                        })
+                        .into_any_element(),
+                )
+            }
+        }
+    }
+
+    fn documentation_aside(
+        &self,
+        _window: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> Option<DocumentationAside> {
+        use std::rc::Rc;
+
+        let entry = match self.filtered_entries.get(self.selected_index)? {
+            ProfilePickerEntry::Profile(entry) => entry,
+            ProfilePickerEntry::Header(_) => return None,
+        };
+
+        let candidate = self.candidates.get(entry.candidate_index)?;
+        let docs_aside = Self::documentation(candidate)?.to_string();
+
+        let settings = AgentSettings::get_global(cx);
+        let side = match settings.dock {
+            settings::DockPosition::Left => DocumentationSide::Right,
+            settings::DockPosition::Bottom | settings::DockPosition::Right => {
+                DocumentationSide::Left
+            }
+        };
+
+        Some(DocumentationAside {
+            side,
+            edge: DocumentationEdge::Top,
+            render: Rc::new(move |_| Label::new(docs_aside.clone()).into_any_element()),
+        })
+    }
+
+    fn render_footer(
+        &self,
+        _: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> Option<gpui::AnyElement> {
+        Some(
+            h_flex()
+                .w_full()
+                .border_t_1()
+                .border_color(cx.theme().colors().border_variant)
+                .p_1()
+                .gap_4()
+                .justify_between()
+                .child(
+                    Button::new("configure", "Configure")
+                        .icon(IconName::Settings)
+                        .icon_size(IconSize::Small)
+                        .icon_color(Color::Muted)
+                        .icon_position(IconPosition::Start)
+                        .on_click(|_, window, cx| {
+                            window.dispatch_action(ManageProfiles::default().boxed_clone(), cx);
+                        }),
+                )
+                .into_any(),
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use fs::FakeFs;
+    use gpui::TestAppContext;
+
+    #[gpui::test]
+    fn entries_include_custom_profiles(_cx: &mut TestAppContext) {
+        let candidates = vec![
+            ProfileCandidate {
+                id: AgentProfileId("write".into()),
+                name: SharedString::from("Write"),
+                is_builtin: true,
+            },
+            ProfileCandidate {
+                id: AgentProfileId("my-custom".into()),
+                name: SharedString::from("My Custom"),
+                is_builtin: false,
+            },
+        ];
+
+        let entries = ProfilePickerDelegate::entries_from_candidates(&candidates);
+
+        assert!(entries.iter().any(|entry| matches!(
+            entry,
+            ProfilePickerEntry::Profile(profile)
+                if candidates[profile.candidate_index].id.as_str() == "my-custom"
+        )));
+        assert!(entries.iter().any(|entry| matches!(
+            entry,
+            ProfilePickerEntry::Header(label) if label.as_ref() == "Custom Profiles"
+        )));
+    }
+
+    #[gpui::test]
+    fn fuzzy_filter_returns_no_results_and_keeps_configure(cx: &mut TestAppContext) {
+        let candidates = vec![ProfileCandidate {
+            id: AgentProfileId("write".into()),
+            name: SharedString::from("Write"),
+            is_builtin: true,
+        }];
+
+        let delegate = ProfilePickerDelegate {
+            fs: FakeFs::new(cx.executor()),
+            provider: Arc::new(TestProfileProvider::new(AgentProfileId("write".into()))),
+            background: cx.executor(),
+            candidates,
+            string_candidates: Arc::new(Vec::new()),
+            filtered_entries: Vec::new(),
+            selected_index: 0,
+            query: String::new(),
+            cancel: None,
+        };
+
+        let matches = Vec::new(); // No matches
+        let _entries = delegate.entries_from_matches(matches);
+    }
+
+    #[gpui::test]
+    fn active_profile_selection_logic_works(cx: &mut TestAppContext) {
+        let candidates = vec![
+            ProfileCandidate {
+                id: AgentProfileId("write".into()),
+                name: SharedString::from("Write"),
+                is_builtin: true,
+            },
+            ProfileCandidate {
+                id: AgentProfileId("ask".into()),
+                name: SharedString::from("Ask"),
+                is_builtin: true,
+            },
+        ];
+
+        let delegate = ProfilePickerDelegate {
+            fs: FakeFs::new(cx.executor()),
+            provider: Arc::new(TestProfileProvider::new(AgentProfileId("write".into()))),
+            background: cx.executor(),
+            candidates,
+            string_candidates: Arc::new(Vec::new()),
+            filtered_entries: vec![
+                ProfilePickerEntry::Profile(ProfileMatchEntry {
+                    candidate_index: 0,
+                    positions: Vec::new(),
+                }),
+                ProfilePickerEntry::Profile(ProfileMatchEntry {
+                    candidate_index: 1,
+                    positions: Vec::new(),
+                }),
+            ],
+            selected_index: 0,
+            query: String::new(),
+            cancel: None,
+        };
+
+        // Active profile should be found at index 0
+        let active_index = delegate.index_of_profile(&AgentProfileId("write".into()));
+        assert_eq!(active_index, Some(0));
+    }
+
+    struct TestProfileProvider {
+        profile_id: AgentProfileId,
+    }
+
+    impl TestProfileProvider {
+        fn new(profile_id: AgentProfileId) -> Self {
+            Self { profile_id }
+        }
+    }
+
+    impl ProfileProvider for TestProfileProvider {
+        fn profile_id(&self, _cx: &App) -> AgentProfileId {
+            self.profile_id.clone()
+        }
+
+        fn set_profile(&self, _profile_id: AgentProfileId, _cx: &mut App) {}
+
+        fn profiles_supported(&self, _cx: &App) -> bool {
+            true
        }
    }
 }
-
-fn documentation_side(position: DockPosition) -> DocumentationSide {
-    match position {
-        DockPosition::Left => DocumentationSide::Right,
-        DockPosition::Bottom => DocumentationSide::Left,
-        DockPosition::Right => DocumentationSide::Left,
-    }
-}
--- a/crates/agent_ui/src/terminal_inline_assistant.rs
+++ b/crates/agent_ui/src/terminal_inline_assistant.rs
@@ -238,7 +238,7 @@ impl TerminalInlineAssistant {
                let latest_output = terminal.last_n_non_empty_lines(DEFAULT_CONTEXT_LINES);
                let working_directory = terminal
                    .working_directory()
-                    .map(|path| path.to_string_lossy().to_string());
+                    .map(|path| path.to_string_lossy().into_owned());
                (latest_output, working_directory)
            })
            .ok()
--- a/crates/agent_ui/src/text_thread_editor.rs
+++ b/crates/agent_ui/src/text_thread_editor.rs
@@ -17,6 +17,7 @@ use editor::{
        BlockPlacement, BlockProperties, BlockStyle, Crease, CreaseMetadata, CustomBlockId, FoldId,
        RenderBlock, ToDisplayPoint,
    },
+    scroll::ScrollOffset,
 };
 use editor::{FoldPlaceholder, display_map::CreaseId};
 use fs::Fs;
@@ -108,7 +109,7 @@ pub enum InsertDraggedFiles {

 #[derive(Copy, Clone, Debug, PartialEq)]
 struct ScrollPosition {
-    offset_before_cursor: gpui::Point<f32>,
+    offset_before_cursor: gpui::Point<ScrollOffset>,
    cursor: Anchor,
 }

@@ -631,7 +632,7 @@ impl TextThreadEditor {
                        let snapshot = editor.snapshot(window, cx);
                        let cursor_point = scroll_position.cursor.to_display_point(&snapshot);
                        let scroll_top =
-                            cursor_point.row().as_f32() - scroll_position.offset_before_cursor.y;
+                            cursor_point.row().as_f64() - scroll_position.offset_before_cursor.y;
                        editor.set_scroll_position(
                            point(scroll_position.offset_before_cursor.x, scroll_top),
                            window,
@@ -979,7 +980,7 @@ impl TextThreadEditor {
            let cursor_row = cursor
                .to_display_point(&snapshot.display_snapshot)
                .row()
-                .as_f32();
+                .as_f64();
            let scroll_position = editor
                .scroll_manager
                .anchor()
--- a/crates/agent_ui/src/ui/burn_mode_tooltip.rs
+++ b/crates/agent_ui/src/ui/burn_mode_tooltip.rs
@@ -48,7 +48,7 @@ impl Render for BurnModeTooltip {
        let keybinding = KeyBinding::for_action(&ToggleBurnMode, window, cx)
            .map(|kb| kb.size(rems_from_px(12.)));

-        tooltip_container(window, cx, |this, _, _| {
+        tooltip_container(cx, |this, _| {
            this
                .child(
                    h_flex()
--- a/crates/agent_ui/src/ui/context_pill.rs
+++ b/crates/agent_ui/src/ui/context_pill.rs
@@ -704,7 +704,7 @@ impl ContextPillHover {

 impl Render for ContextPillHover {
    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        tooltip_container(window, cx, move |this, window, cx| {
+        tooltip_container(cx, move |this, cx| {
            this.occlude()
                .on_mouse_move(|_, _, cx| cx.stop_propagation())
                .on_mouse_down(MouseButton::Left, |_, _, cx| cx.stop_propagation())
--- a/crates/agent_ui/src/ui/onboarding_modal.rs
+++ b/crates/agent_ui/src/ui/onboarding_modal.rs
@@ -40,7 +40,7 @@ impl AgentOnboardingModal {
    }

    fn view_blog(&mut self, _: &ClickEvent, _: &mut Window, cx: &mut Context<Self>) {
-        cx.open_url("http://zed.dev/blog/fastest-ai-code-editor");
+        cx.open_url("https://zed.dev/blog/fastest-ai-code-editor");
        cx.notify();

        agent_onboarding_event!("Blog Link Clicked");
--- a/crates/agent_ui/src/ui/unavailable_editing_tooltip.rs
+++ b/crates/agent_ui/src/ui/unavailable_editing_tooltip.rs
@@ -12,8 +12,8 @@ impl UnavailableEditingTooltip {
 }

 impl Render for UnavailableEditingTooltip {
-    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        tooltip_container(window, cx, |this, _, _| {
+    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        tooltip_container(cx, |this, _| {
            this.child(Label::new("Unavailable Editing")).child(
                div().max_w_64().child(
                    Label::new(format!(
--- a/crates/anthropic/src/anthropic.rs
+++ b/crates/anthropic/src/anthropic.rs
@@ -67,7 +67,6 @@ pub enum Model {
        alias = "claude-opus-4-1-thinking-latest"
    )]
    ClaudeOpus4_1Thinking,
-    #[default]
    #[serde(rename = "claude-sonnet-4", alias = "claude-sonnet-4-latest")]
    ClaudeSonnet4,
    #[serde(
@@ -75,6 +74,14 @@ pub enum Model {
        alias = "claude-sonnet-4-thinking-latest"
    )]
    ClaudeSonnet4Thinking,
+    #[default]
+    #[serde(rename = "claude-sonnet-4-5", alias = "claude-sonnet-4-5-latest")]
+    ClaudeSonnet4_5,
+    #[serde(
+        rename = "claude-sonnet-4-5-thinking",
+        alias = "claude-sonnet-4-5-thinking-latest"
+    )]
+    ClaudeSonnet4_5Thinking,
    #[serde(rename = "claude-3-7-sonnet", alias = "claude-3-7-sonnet-latest")]
    Claude3_7Sonnet,
    #[serde(
@@ -133,6 +140,14 @@ impl Model {
            return Ok(Self::ClaudeOpus4);
        }

+        if id.starts_with("claude-sonnet-4-5-thinking") {
+            return Ok(Self::ClaudeSonnet4_5Thinking);
+        }
+
+        if id.starts_with("claude-sonnet-4-5") {
+            return Ok(Self::ClaudeSonnet4_5);
+        }
+
        if id.starts_with("claude-sonnet-4-thinking") {
            return Ok(Self::ClaudeSonnet4Thinking);
        }
@@ -180,6 +195,8 @@ impl Model {
            Self::ClaudeOpus4_1Thinking => "claude-opus-4-1-thinking-latest",
            Self::ClaudeSonnet4 => "claude-sonnet-4-latest",
            Self::ClaudeSonnet4Thinking => "claude-sonnet-4-thinking-latest",
+            Self::ClaudeSonnet4_5 => "claude-sonnet-4-5-latest",
+            Self::ClaudeSonnet4_5Thinking => "claude-sonnet-4-5-thinking-latest",
            Self::Claude3_5Sonnet => "claude-3-5-sonnet-latest",
            Self::Claude3_7Sonnet => "claude-3-7-sonnet-latest",
            Self::Claude3_7SonnetThinking => "claude-3-7-sonnet-thinking-latest",
@@ -197,6 +214,7 @@ impl Model {
            Self::ClaudeOpus4 | Self::ClaudeOpus4Thinking => "claude-opus-4-20250514",
            Self::ClaudeOpus4_1 | Self::ClaudeOpus4_1Thinking => "claude-opus-4-1-20250805",
            Self::ClaudeSonnet4 | Self::ClaudeSonnet4Thinking => "claude-sonnet-4-20250514",
+            Self::ClaudeSonnet4_5 | Self::ClaudeSonnet4_5Thinking => "claude-sonnet-4-5-20250929",
            Self::Claude3_5Sonnet => "claude-3-5-sonnet-latest",
            Self::Claude3_7Sonnet | Self::Claude3_7SonnetThinking => "claude-3-7-sonnet-latest",
            Self::Claude3_5Haiku => "claude-3-5-haiku-latest",
@@ -215,6 +233,8 @@ impl Model {
            Self::ClaudeOpus4_1Thinking => "Claude Opus 4.1 Thinking",
            Self::ClaudeSonnet4 => "Claude Sonnet 4",
            Self::ClaudeSonnet4Thinking => "Claude Sonnet 4 Thinking",
+            Self::ClaudeSonnet4_5 => "Claude Sonnet 4.5",
+            Self::ClaudeSonnet4_5Thinking => "Claude Sonnet 4.5 Thinking",
            Self::Claude3_7Sonnet => "Claude 3.7 Sonnet",
            Self::Claude3_5Sonnet => "Claude 3.5 Sonnet",
            Self::Claude3_7SonnetThinking => "Claude 3.7 Sonnet Thinking",
@@ -236,6 +256,8 @@ impl Model {
            | Self::ClaudeOpus4_1Thinking
            | Self::ClaudeSonnet4
            | Self::ClaudeSonnet4Thinking
+            | Self::ClaudeSonnet4_5
+            | Self::ClaudeSonnet4_5Thinking
            | Self::Claude3_5Sonnet
            | Self::Claude3_5Haiku
            | Self::Claude3_7Sonnet
@@ -261,6 +283,8 @@ impl Model {
            | Self::ClaudeOpus4_1Thinking
            | Self::ClaudeSonnet4
            | Self::ClaudeSonnet4Thinking
+            | Self::ClaudeSonnet4_5
+            | Self::ClaudeSonnet4_5Thinking
            | Self::Claude3_5Sonnet
            | Self::Claude3_5Haiku
            | Self::Claude3_7Sonnet
@@ -280,6 +304,8 @@ impl Model {
            | Self::ClaudeOpus4_1Thinking
            | Self::ClaudeSonnet4
            | Self::ClaudeSonnet4Thinking
+            | Self::ClaudeSonnet4_5
+            | Self::ClaudeSonnet4_5Thinking
            | Self::Claude3_5Sonnet
            | Self::Claude3_7Sonnet
            | Self::Claude3_7SonnetThinking
@@ -299,6 +325,8 @@ impl Model {
            | Self::ClaudeOpus4_1Thinking
            | Self::ClaudeSonnet4
            | Self::ClaudeSonnet4Thinking
+            | Self::ClaudeSonnet4_5
+            | Self::ClaudeSonnet4_5Thinking
            | Self::Claude3_5Sonnet
            | Self::Claude3_7Sonnet
            | Self::Claude3_7SonnetThinking
@@ -318,6 +346,7 @@ impl Model {
            Self::ClaudeOpus4
            | Self::ClaudeOpus4_1
            | Self::ClaudeSonnet4
+            | Self::ClaudeSonnet4_5
            | Self::Claude3_5Sonnet
            | Self::Claude3_7Sonnet
            | Self::Claude3_5Haiku
@@ -327,6 +356,7 @@ impl Model {
            Self::ClaudeOpus4Thinking
            | Self::ClaudeOpus4_1Thinking
            | Self::ClaudeSonnet4Thinking
+            | Self::ClaudeSonnet4_5Thinking
            | Self::Claude3_7SonnetThinking => AnthropicModelMode::Thinking {
                budget_tokens: Some(4_096),
            },
--- a/crates/askpass/Cargo.toml
+++ b/crates/askpass/Cargo.toml
@@ -16,8 +16,8 @@ anyhow.workspace = true
 futures.workspace = true
 gpui.workspace = true
 net.workspace = true
-proto.workspace = true
 smol.workspace = true
+log.workspace = true
 tempfile.workspace = true
 util.workspace = true
 workspace-hack.workspace = true
@@ -25,3 +25,6 @@ zeroize.workspace = true

 [target.'cfg(target_os = "windows")'.dependencies]
 windows.workspace = true
+
+[package.metadata.cargo-machete]
+ignored = ["log"]
--- a/crates/askpass/src/askpass.rs
+++ b/crates/askpass/src/askpass.rs
@@ -1,10 +1,16 @@
 mod encrypted_password;

-pub use encrypted_password::{EncryptedPassword, ProcessExt};
+pub use encrypted_password::{EncryptedPassword, IKnowWhatIAmDoingAndIHaveReadTheDocs};

-#[cfg(target_os = "windows")]
+use net::async_net::UnixListener;
+use smol::lock::Mutex;
+use util::fs::make_file_executable;
+
+use std::ffi::OsStr;
+use std::ops::ControlFlow;
+use std::sync::Arc;
 use std::sync::OnceLock;
-use std::{ffi::OsStr, time::Duration};
+use std::time::Duration;

 use anyhow::{Context as _, Result};
 use futures::channel::{mpsc, oneshot};
@@ -14,9 +20,13 @@ use futures::{
 };
 use gpui::{AsyncApp, BackgroundExecutor, Task};
 use smol::fs;
-use util::ResultExt as _;
+use util::{ResultExt as _, debug_panic, maybe, paths::PathExt};

-use crate::encrypted_password::decrypt;
+/// Path to the program used for askpass
+///
+/// On Unix and remote servers, this defaults to the current executable
+/// On Windows, this is set to the CLI variant of zed
+static ASKPASS_PROGRAM: OnceLock<std::path::PathBuf> = OnceLock::new();

 #[derive(PartialEq, Eq)]
 pub enum AskPassResult {
@@ -26,6 +36,7 @@ pub enum AskPassResult {

 pub struct AskPassDelegate {
    tx: mpsc::UnboundedSender<(String, oneshot::Sender<EncryptedPassword>)>,
+    executor: BackgroundExecutor,
    _task: Task<()>,
 }

@@ -43,24 +54,27 @@ impl AskPassDelegate {
                password_prompt(prompt, channel, cx);
            }
        });
-        Self { tx, _task: task }
+        Self {
+            tx,
+            _task: task,
+            executor: cx.background_executor().clone(),
+        }
    }

-    pub async fn ask_password(&mut self, prompt: String) -> Result<EncryptedPassword> {
-        let (tx, rx) = oneshot::channel();
-        self.tx.send((prompt, tx)).await?;
-        Ok(rx.await?)
+    pub fn ask_password(&mut self, prompt: String) -> Task<Option<EncryptedPassword>> {
+        let mut this_tx = self.tx.clone();
+        self.executor.spawn(async move {
+            let (tx, rx) = oneshot::channel();
+            this_tx.send((prompt, tx)).await.ok()?;
+            rx.await.ok()
+        })
    }
 }

 pub struct AskPassSession {
-    #[cfg(not(target_os = "windows"))]
-    script_path: std::path::PathBuf,
-    #[cfg(target_os = "windows")]
-    askpass_helper: String,
    #[cfg(target_os = "windows")]
    secret: std::sync::Arc<OnceLock<EncryptedPassword>>,
-    _askpass_task: Task<()>,
+    askpass_task: PasswordProxy,
    askpass_opened_rx: Option<oneshot::Receiver<()>>,
    askpass_kill_master_rx: Option<oneshot::Receiver<()>>,
 }
@@ -75,104 +89,57 @@ impl AskPassSession {
    /// You must retain this session until the master process exits.
    #[must_use]
    pub async fn new(executor: &BackgroundExecutor, mut delegate: AskPassDelegate) -> Result<Self> {
-        use net::async_net::UnixListener;
-        use util::fs::make_file_executable;
-
        #[cfg(target_os = "windows")]
        let secret = std::sync::Arc::new(OnceLock::new());
-        let temp_dir = tempfile::Builder::new().prefix("zed-askpass").tempdir()?;
-        let askpass_socket = temp_dir.path().join("askpass.sock");
-        let askpass_script_path = temp_dir.path().join(ASKPASS_SCRIPT_NAME);
        let (askpass_opened_tx, askpass_opened_rx) = oneshot::channel::<()>();
-        let listener = UnixListener::bind(&askpass_socket).context("creating askpass socket")?;
-        #[cfg(not(target_os = "windows"))]
-        let zed_path = util::get_shell_safe_zed_path()?;
-        #[cfg(target_os = "windows")]
-        let zed_path = std::env::current_exe()
-            .context("finding current executable path for use in askpass")?;
+
+        let askpass_opened_tx = Arc::new(Mutex::new(Some(askpass_opened_tx)));

        let (askpass_kill_master_tx, askpass_kill_master_rx) = oneshot::channel::<()>();
-        let mut kill_tx = Some(askpass_kill_master_tx);
+        let kill_tx = Arc::new(Mutex::new(Some(askpass_kill_master_tx)));

        #[cfg(target_os = "windows")]
        let askpass_secret = secret.clone();
-        let askpass_task = executor.spawn(async move {
-            let mut askpass_opened_tx = Some(askpass_opened_tx);
+        let get_password = {
+            let executor = executor.clone();

-            while let Ok((mut stream, _)) = listener.accept().await {
-                if let Some(askpass_opened_tx) = askpass_opened_tx.take() {
-                    askpass_opened_tx.send(()).ok();
-                }
-                let mut buffer = Vec::new();
-                let mut reader = BufReader::new(&mut stream);
-                if reader.read_until(b'\0', &mut buffer).await.is_err() {
-                    buffer.clear();
-                }
-                let prompt = String::from_utf8_lossy(&buffer);
-                if let Some(password) = delegate
-                    .ask_password(prompt.to_string())
-                    .await
-                    .context("getting askpass password")
-                    .log_err()
-                {
-                    #[cfg(target_os = "windows")]
-                    {
-                        askpass_secret.get_or_init(|| password.clone());
+            move |prompt| {
+                let prompt = delegate.ask_password(prompt);
+                let kill_tx = kill_tx.clone();
+                let askpass_opened_tx = askpass_opened_tx.clone();
+                #[cfg(target_os = "windows")]
+                let askpass_secret = askpass_secret.clone();
+                executor.spawn(async move {
+                    if let Some(askpass_opened_tx) = askpass_opened_tx.lock().await.take() {
+                        askpass_opened_tx.send(()).ok();
                    }
-                    if let Ok(decrypted) = decrypt(password) {
-                        stream.write_all(decrypted.as_bytes()).await.log_err();
+                    if let Some(password) = prompt.await {
+                        #[cfg(target_os = "windows")]
+                        {
+                            _ = askpass_secret.set(password.clone());
+                        }
+                        ControlFlow::Continue(Ok(password))
+                    } else {
+                        if let Some(kill_tx) = kill_tx.lock().await.take() {
+                            kill_tx.send(()).log_err();
+                        }
+                        ControlFlow::Break(())
                    }
-                } else {
-                    if let Some(kill_tx) = kill_tx.take() {
-                        kill_tx.send(()).log_err();
-                    }
-                    // note: we expect the caller to drop this task when it's done.
-                    // We need to keep the stream open until the caller is done to avoid
-                    // spurious errors from ssh.
-                    std::future::pending::<()>().await;
-                    drop(stream);
-                }
+                })
            }
-            drop(temp_dir)
-        });
-
-        // Create an askpass script that communicates back to this process.
-        let askpass_script = generate_askpass_script(&zed_path, &askpass_socket);
-        fs::write(&askpass_script_path, askpass_script)
-            .await
-            .with_context(|| format!("creating askpass script at {askpass_script_path:?}"))?;
-        make_file_executable(&askpass_script_path).await?;
-        #[cfg(target_os = "windows")]
-        let askpass_helper = format!(
-            "powershell.exe -ExecutionPolicy Bypass -File {}",
-            askpass_script_path.display()
-        );
+        };
+        let askpass_task = PasswordProxy::new(get_password, executor.clone()).await?;

        Ok(Self {
-            #[cfg(not(target_os = "windows"))]
-            script_path: askpass_script_path,
-
            #[cfg(target_os = "windows")]
            secret,
-            #[cfg(target_os = "windows")]
-            askpass_helper,

-            _askpass_task: askpass_task,
+            askpass_task,
            askpass_kill_master_rx: Some(askpass_kill_master_rx),
            askpass_opened_rx: Some(askpass_opened_rx),
        })
    }

-    #[cfg(not(target_os = "windows"))]
-    pub fn script_path(&self) -> impl AsRef<OsStr> {
-        &self.script_path
-    }
-
-    #[cfg(target_os = "windows")]
-    pub fn script_path(&self) -> impl AsRef<OsStr> {
-        &self.askpass_helper
-    }
-
    // This will run the askpass task forever, resolving as many authentication requests as needed.
    // The caller is responsible for examining the result of their own commands and cancelling this
    // future when this is no longer needed. Note that this can only be called once, but due to the
@@ -204,8 +171,109 @@ impl AskPassSession {
    pub fn get_password(&self) -> Option<EncryptedPassword> {
        self.secret.get().cloned()
    }
+
+    pub fn script_path(&self) -> impl AsRef<OsStr> {
+        self.askpass_task.script_path()
+    }
 }

+pub struct PasswordProxy {
+    _task: Task<()>,
+    #[cfg(not(target_os = "windows"))]
+    askpass_script_path: std::path::PathBuf,
+    #[cfg(target_os = "windows")]
+    askpass_helper: String,
+}
+
+impl PasswordProxy {
+    pub async fn new(
+        mut get_password: impl FnMut(String) -> Task<ControlFlow<(), Result<EncryptedPassword>>>
+        + 'static
+        + Send
+        + Sync,
+        executor: BackgroundExecutor,
+    ) -> Result<Self> {
+        let temp_dir = tempfile::Builder::new().prefix("zed-askpass").tempdir()?;
+        let askpass_socket = temp_dir.path().join("askpass.sock");
+        let askpass_script_path = temp_dir.path().join(ASKPASS_SCRIPT_NAME);
+        let current_exec =
+            std::env::current_exe().context("Failed to determine current zed executable path.")?;
+
+        let askpass_program = ASKPASS_PROGRAM
+            .get_or_init(|| current_exec)
+            .try_shell_safe()
+            .context("Failed to shell-escape Askpass program path.")?
+            .to_string();
+        // Create an askpass script that communicates back to this process.
+        let askpass_script = generate_askpass_script(&askpass_program, &askpass_socket);
+        let _task = executor.spawn(async move {
+            maybe!(async move {
+                let listener =
+                    UnixListener::bind(&askpass_socket).context("creating askpass socket")?;
+
+                while let Ok((mut stream, _)) = listener.accept().await {
+                    let mut buffer = Vec::new();
+                    let mut reader = BufReader::new(&mut stream);
+                    if reader.read_until(b'\0', &mut buffer).await.is_err() {
+                        buffer.clear();
+                    }
+                    let prompt = String::from_utf8_lossy(&buffer).into_owned();
+                    let password = get_password(prompt).await;
+                    match password {
+                        ControlFlow::Continue(password) => {
+                            if let Ok(password) = password
+                                && let Ok(decrypted) =
+                                    password.decrypt(IKnowWhatIAmDoingAndIHaveReadTheDocs)
+                            {
+                                stream.write_all(decrypted.as_bytes()).await.log_err();
+                            }
+                        }
+                        ControlFlow::Break(()) => {
+                            // note: we expect the caller to drop this task when it's done.
+                            // We need to keep the stream open until the caller is done to avoid
+                            // spurious errors from ssh.
+                            std::future::pending::<()>().await;
+                            drop(stream);
+                        }
+                    }
+                }
+                drop(temp_dir);
+                Result::<_, anyhow::Error>::Ok(())
+            })
+            .await
+            .log_err();
+        });
+
+        fs::write(&askpass_script_path, askpass_script)
+            .await
+            .with_context(|| format!("creating askpass script at {askpass_script_path:?}"))?;
+        make_file_executable(&askpass_script_path).await?;
+        #[cfg(target_os = "windows")]
+        let askpass_helper = format!(
+            "powershell.exe -ExecutionPolicy Bypass -File {}",
+            askpass_script_path.display()
+        );
+
+        Ok(Self {
+            _task,
+            #[cfg(not(target_os = "windows"))]
+            askpass_script_path,
+            #[cfg(target_os = "windows")]
+            askpass_helper,
+        })
+    }
+
+    pub fn script_path(&self) -> impl AsRef<OsStr> {
+        #[cfg(not(target_os = "windows"))]
+        {
+            &self.askpass_script_path
+        }
+        #[cfg(target_os = "windows")]
+        {
+            &self.askpass_helper
+        }
+    }
+}
 /// The main function for when Zed is running in netcat mode for use in askpass.
 /// Called from both the remote server binary and the zed binary in their respective main functions.
 pub fn main(socket: &str) {
@@ -252,12 +320,17 @@ pub fn main(socket: &str) {
    }
 }

+pub fn set_askpass_program(path: std::path::PathBuf) {
+    if ASKPASS_PROGRAM.set(path).is_err() {
+        debug_panic!("askpass program has already been set");
+    }
+}
+
 #[inline]
 #[cfg(not(target_os = "windows"))]
-fn generate_askpass_script(zed_path: &str, askpass_socket: &std::path::Path) -> String {
+fn generate_askpass_script(askpass_program: &str, askpass_socket: &std::path::Path) -> String {
    format!(
-        "{shebang}\n{print_args} | {zed_exe} --askpass={askpass_socket} 2> /dev/null \n",
-        zed_exe = zed_path,
+        "{shebang}\n{print_args} | {askpass_program} --askpass={askpass_socket} 2> /dev/null \n",
        askpass_socket = askpass_socket.display(),
        print_args = "printf '%s\\0' \"$@\"",
        shebang = "#!/bin/sh",
@@ -266,13 +339,12 @@ fn generate_askpass_script(zed_path: &str, askpass_socket: &std::path::Path) ->

 #[inline]
 #[cfg(target_os = "windows")]
-fn generate_askpass_script(zed_path: &std::path::Path, askpass_socket: &std::path::Path) -> String {
+fn generate_askpass_script(askpass_program: &str, askpass_socket: &std::path::Path) -> String {
    format!(
        r#"
        $ErrorActionPreference = 'Stop';
-        ($args -join [char]0) | & "{zed_exe}" --askpass={askpass_socket} 2> $null
+        ($args -join [char]0) | & "{askpass_program}" --askpass={askpass_socket} 2> $null
        "#,
-        zed_exe = zed_path.display(),
        askpass_socket = askpass_socket.display(),
    )
 }
--- a/crates/askpass/src/encrypted_password.rs
+++ b/crates/askpass/src/encrypted_password.rs
@@ -21,27 +21,6 @@ type LengthWithoutPadding = u32;
 #[derive(Clone)]
 pub struct EncryptedPassword(Vec<u8>, LengthWithoutPadding);

-pub trait ProcessExt {
-    fn encrypted_env(&mut self, name: &str, value: EncryptedPassword) -> &mut Self;
-}
-
-impl ProcessExt for smol::process::Command {
-    fn encrypted_env(&mut self, name: &str, value: EncryptedPassword) -> &mut Self {
-        if let Ok(password) = decrypt(value) {
-            self.env(name, password);
-        }
-        self
-    }
-}
-
-impl TryFrom<EncryptedPassword> for proto::AskPassResponse {
-    type Error = anyhow::Error;
-    fn try_from(pw: EncryptedPassword) -> Result<Self, Self::Error> {
-        let pw = decrypt(pw)?;
-        Ok(Self { response: pw })
-    }
-}
-
 impl Drop for EncryptedPassword {
    fn drop(&mut self) {
        self.0.zeroize();
@@ -67,7 +46,7 @@ impl TryFrom<&str> for EncryptedPassword {
                unsafe {
                    CryptProtectMemory(
                        value.as_mut_ptr() as _,
-                        len,
+                        padded_length,
                        CRYPTPROTECTMEMORY_SAME_PROCESS,
                    )?;
                }
@@ -79,38 +58,45 @@ impl TryFrom<&str> for EncryptedPassword {
    }
 }

-pub(crate) fn decrypt(mut password: EncryptedPassword) -> Result<String> {
-    #[cfg(windows)]
-    {
-        use anyhow::Context;
-        use windows::Win32::Security::Cryptography::{
-            CRYPTPROTECTMEMORY_BLOCK_SIZE, CRYPTPROTECTMEMORY_SAME_PROCESS, CryptUnprotectMemory,
-        };
-        assert_eq!(
-            password.0.len() % CRYPTPROTECTMEMORY_BLOCK_SIZE as usize,
-            0,
-            "Violated pre-condition (buffer size <{}> must be a multiple of CRYPTPROTECTMEMORY_BLOCK_SIZE <{}>) for CryptUnprotectMemory.",
-            password.0.len(),
-            CRYPTPROTECTMEMORY_BLOCK_SIZE
-        );
-        if password.1 != 0 {
-            unsafe {
-                CryptUnprotectMemory(
-                    password.0.as_mut_ptr() as _,
-                    password.1,
-                    CRYPTPROTECTMEMORY_SAME_PROCESS,
-                )
-                .context("while decrypting a SSH password")?
+/// Read the docs for [EncryptedPassword]; please take care of not storing the plaintext string in memory for extended
+/// periods of time.
+pub struct IKnowWhatIAmDoingAndIHaveReadTheDocs;
+
+impl EncryptedPassword {
+    pub fn decrypt(mut self, _: IKnowWhatIAmDoingAndIHaveReadTheDocs) -> Result<String> {
+        #[cfg(windows)]
+        {
+            use anyhow::Context;
+            use windows::Win32::Security::Cryptography::{
+                CRYPTPROTECTMEMORY_BLOCK_SIZE, CRYPTPROTECTMEMORY_SAME_PROCESS,
+                CryptUnprotectMemory,
            };
+            assert_eq!(
+                self.0.len() % CRYPTPROTECTMEMORY_BLOCK_SIZE as usize,
+                0,
+                "Violated pre-condition (buffer size <{}> must be a multiple of CRYPTPROTECTMEMORY_BLOCK_SIZE <{}>) for CryptUnprotectMemory.",
+                self.0.len(),
+                CRYPTPROTECTMEMORY_BLOCK_SIZE
+            );
+            if self.1 != 0 {
+                unsafe {
+                    CryptUnprotectMemory(
+                        self.0.as_mut_ptr() as _,
+                        self.0.len().try_into()?,
+                        CRYPTPROTECTMEMORY_SAME_PROCESS,
+                    )
+                    .context("while decrypting a SSH password")?
+                };

-            {
-                // Remove padding
-                _ = password.0.drain(password.1 as usize..);
+                {
+                    // Remove padding
+                    _ = self.0.drain(self.1 as usize..);
+                }
            }
-        }

-        Ok(String::from_utf8(std::mem::take(&mut password.0))?)
+            Ok(String::from_utf8(std::mem::take(&mut self.0))?)
+        }
+        #[cfg(not(windows))]
+        Ok(String::from_utf8(std::mem::take(&mut self.0))?)
    }
-    #[cfg(not(windows))]
-    Ok(String::from_utf8(std::mem::take(&mut password.0))?)
 }
--- a/crates/assistant_slash_command/src/extension_slash_command.rs
+++ b/crates/assistant_slash_command/src/extension_slash_command.rs
@@ -50,7 +50,7 @@ impl WorktreeDelegate for WorktreeDelegateAdapter {
    }

    fn root_path(&self) -> String {
-        self.0.worktree_root_path().to_string_lossy().to_string()
+        self.0.worktree_root_path().to_string_lossy().into_owned()
    }

    async fn read_text_file(&self, path: &RelPath) -> Result<String> {
@@ -61,7 +61,7 @@ impl WorktreeDelegate for WorktreeDelegateAdapter {
        self.0
            .which(binary_name.as_ref())
            .await
-            .map(|path| path.to_string_lossy().to_string())
+            .map(|path| path.to_string_lossy().into_owned())
    }

    async fn shell_env(&self) -> Vec<(String, String)> {
--- a/crates/assistant_slash_commands/src/diagnostics_command.rs
+++ b/crates/assistant_slash_commands/src/diagnostics_command.rs
@@ -6,7 +6,7 @@ use assistant_slash_command::{
 use fuzzy::{PathMatch, StringMatchCandidate};
 use gpui::{App, Entity, Task, WeakEntity};
 use language::{
-    Anchor, BufferSnapshot, DiagnosticEntry, DiagnosticSeverity, LspAdapterDelegate,
+    Anchor, BufferSnapshot, DiagnosticEntryRef, DiagnosticSeverity, LspAdapterDelegate,
    OffsetRangeExt, ToOffset,
 };
 use project::{DiagnosticSummary, PathMatchCandidateSet, Project};
@@ -367,7 +367,7 @@ pub fn collect_buffer_diagnostics(

 fn collect_diagnostic(
    output: &mut SlashCommandOutput,
-    entry: &DiagnosticEntry<Anchor>,
+    entry: &DiagnosticEntryRef<'_, Anchor>,
    snapshot: &BufferSnapshot,
    include_warnings: bool,
 ) {
--- a/crates/assistant_slash_commands/src/selection_command.rs
+++ b/crates/assistant_slash_commands/src/selection_command.rs
@@ -139,7 +139,7 @@ pub fn selections_creases(
        let language_name = language_name.as_deref().unwrap_or("");
        let filename = snapshot
            .file_at(range.start)
-            .map(|file| file.full_path(cx).to_string_lossy().to_string());
+            .map(|file| file.full_path(cx).to_string_lossy().into_owned());
        let text = if language_name == "markdown" {
            selected_text
                .lines()
--- a/crates/assistant_tools/src/edit_file_tool.rs
+++ b/crates/assistant_tools/src/edit_file_tool.rs
@@ -17,7 +17,7 @@ use editor::{
 use futures::StreamExt;
 use gpui::{
    Animation, AnimationExt, AnyWindowHandle, App, AppContext, AsyncApp, Entity, Task,
-    TextStyleRefinement, WeakEntity, pulsating_between, px,
+    TextStyleRefinement, WeakEntity, pulsating_between,
 };
 use indoc::formatdoc;
 use language::{
@@ -1003,7 +1003,7 @@ impl ToolCard for EditFileToolCard {
                font_size: Some(
                    TextSize::Small
                        .rems(cx)
-                        .to_pixels(ThemeSettings::get_global(cx).agent_font_size(cx))
+                        .to_pixels(ThemeSettings::get_global(cx).agent_ui_font_size(cx))
                        .into(),
                ),
                ..TextStyleRefinement::default()
@@ -1102,7 +1102,7 @@ impl ToolCard for EditFileToolCard {
                    .relative()
                    .h_full()
                    .when(!self.full_height_expanded, |editor_container| {
-                        editor_container.max_h(px(COLLAPSED_LINES as f32 * editor_line_height.0))
+                        editor_container.max_h(COLLAPSED_LINES as f32 * editor_line_height)
                    })
                    .overflow_hidden()
                    .border_t_1()
@@ -1161,7 +1161,7 @@ async fn build_buffer(
    LineEnding::normalize(&mut text);
    let text = Rope::from(text);
    let language = cx
-        .update(|_cx| language_registry.language_for_file_path(&path))?
+        .update(|_cx| language_registry.load_language_for_file_path(&path))?
        .await
        .ok();
    let buffer = cx.new(|cx| {
--- a/crates/assistant_tools/src/find_path_tool.rs
+++ b/crates/assistant_tools/src/find_path_tool.rs
@@ -262,7 +262,7 @@ impl ToolCard for FindPathToolCard {
                    .children(self.paths.iter().enumerate().map(|(index, path)| {
                        let path_clone = path.clone();
                        let workspace_clone = workspace.clone();
-                        let button_label = path.to_string_lossy().to_string();
+                        let button_label = path.to_string_lossy().into_owned();

                        Button::new(("path", index), button_label)
                            .icon(IconName::ArrowUpRight)
--- a/crates/assistant_tools/src/open_tool.rs
+++ b/crates/assistant_tools/src/open_tool.rs
@@ -104,7 +104,7 @@ mod tests {
    async fn test_to_absolute_path(cx: &mut TestAppContext) {
        init_test(cx);
        let temp_dir = TempDir::new().expect("Failed to create temp directory");
-        let temp_path = temp_dir.path().to_string_lossy().to_string();
+        let temp_path = temp_dir.path().to_string_lossy().into_owned();

        let fs = FakeFs::new(cx.executor());
        fs.insert_tree(
--- a/crates/assistant_tools/src/terminal_tool.rs
+++ b/crates/assistant_tools/src/terminal_tool.rs
@@ -18,7 +18,7 @@ use portable_pty::{CommandBuilder, PtySize, native_pty_system};
 use project::Project;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::Settings;
+use settings::{Settings, SettingsLocation};
 use std::{
    env,
    path::{Path, PathBuf},
@@ -27,12 +27,13 @@ use std::{
    time::{Duration, Instant},
 };
 use task::{Shell, ShellBuilder};
+use terminal::terminal_settings::TerminalSettings;
 use terminal_view::TerminalView;
 use theme::ThemeSettings;
 use ui::{CommonAnimationExt, Disclosure, Tooltip, prelude::*};
 use util::{
-    ResultExt, get_default_system_shell, markdown::MarkdownInlineCode, size::format_file_size,
-    time::duration_alt_display,
+    ResultExt, get_default_system_shell_preferring_bash, markdown::MarkdownInlineCode,
+    size::format_file_size, time::duration_alt_display,
 };
 use workspace::Workspace;

@@ -119,17 +120,29 @@ impl Tool for TerminalTool {
        };

        let cwd = working_dir.clone();
-        let env = match &working_dir {
+        let env = match &cwd {
            Some(dir) => project.update(cx, |project, cx| {
-                project.directory_environment(dir.as_path().into(), cx)
+                let worktree = project.find_worktree(dir.as_path(), cx);
+                let shell = TerminalSettings::get(
+                    worktree.as_ref().map(|(worktree, path)| SettingsLocation {
+                        worktree_id: worktree.read(cx).id(),
+                        path: &path,
+                    }),
+                    cx,
+                )
+                .shell
+                .clone();
+                project.directory_environment(&shell, dir.as_path().into(), cx)
            }),
            None => Task::ready(None).shared(),
        };
-        let remote_shell = project.update(cx, |project, cx| {
-            project
-                .remote_client()
-                .and_then(|r| r.read(cx).default_system_shell())
-        });
+        let shell = project
+            .update(cx, |project, cx| {
+                project
+                    .remote_client()
+                    .and_then(|r| r.read(cx).default_system_shell())
+            })
+            .unwrap_or_else(|| get_default_system_shell_preferring_bash());

        let env = cx.spawn(async move |_| {
            let mut env = env.await.unwrap_or_default();
@@ -139,18 +152,22 @@ impl Tool for TerminalTool {
            env
        });

+        let build_cmd = {
+            let input_command = input.command.clone();
+            move || {
+                ShellBuilder::new(&Shell::Program(shell))
+                    .redirect_stdin_to_dev_null()
+                    .build(Some(input_command), &[])
+            }
+        };
+
        let Some(window) = window else {
            // Headless setup, a test or eval. Our terminal subsystem requires a workspace,
            // so bypass it and provide a convincing imitation using a pty.
            let task = cx.background_spawn(async move {
                let env = env.await;
                let pty_system = native_pty_system();
-                let (command, args) = ShellBuilder::new(
-                    remote_shell.as_deref(),
-                    &Shell::Program(get_default_system_shell()),
-                )
-                .redirect_stdin_to_dev_null()
-                .build(Some(input.command.clone()), &[]);
+                let (command, args) = build_cmd();
                let mut cmd = CommandBuilder::new(command);
                cmd.args(args);
                for (k, v) in env {
@@ -187,16 +204,10 @@ impl Tool for TerminalTool {
            };
        };

-        let command = input.command.clone();
        let terminal = cx.spawn({
            let project = project.downgrade();
            async move |cx| {
-                let (command, args) = ShellBuilder::new(
-                    remote_shell.as_deref(),
-                    &Shell::Program(get_default_system_shell()),
-                )
-                .redirect_stdin_to_dev_null()
-                .build(Some(input.command), &[]);
+                let (command, args) = build_cmd();
                let env = env.await;
                project
                    .update(cx, |project, cx| {
@@ -215,18 +226,18 @@ impl Tool for TerminalTool {
            }
        });

-        let command_markdown =
-            cx.new(|cx| Markdown::new(format!("```bash\n{}\n```", command).into(), None, None, cx));
-
-        let card = cx.new(|cx| {
-            TerminalToolCard::new(
-                command_markdown.clone(),
-                working_dir.clone(),
-                cx.entity_id(),
+        let command_markdown = cx.new(|cx| {
+            Markdown::new(
+                format!("```bash\n{}\n```", input.command).into(),
+                None,
+                None,
                cx,
            )
        });

+        let card =
+            cx.new(|cx| TerminalToolCard::new(command_markdown, working_dir, cx.entity_id(), cx));
+
        let output = cx.spawn({
            let card = card.clone();
            async move |cx| {
@@ -267,7 +278,7 @@ impl Tool for TerminalTool {
                let previous_len = content.len();
                let (processed_content, finished_with_empty_output) = process_content(
                    &content,
-                    &command,
+                    &input.command,
                    exit_status.map(portable_pty::ExitStatus::from),
                );

@@ -475,7 +486,7 @@ impl ToolCard for TerminalToolCard {
            .as_ref()
            .cloned()
            .or_else(|| env::current_dir().ok())
-            .map(|path| format!("{}", path.display()))
+            .map(|path| path.display().to_string())
            .unwrap_or_else(|| "current directory".to_string());

        let header = h_flex()
@@ -693,7 +704,6 @@ mod tests {
    use serde_json::json;
    use settings::{Settings, SettingsStore};
    use terminal::terminal_settings::TerminalSettings;
-    use theme::ThemeSettings;
    use util::{ResultExt as _, test::TempTree};

    use super::*;
@@ -708,7 +718,7 @@ mod tests {
            language::init(cx);
            Project::init_settings(cx);
            workspace::init_settings(cx);
-            ThemeSettings::register(cx);
+            theme::init(theme::LoadThemes::JustBase, cx);
            TerminalSettings::register(cx);
            EditorSettings::register(cx);
        });
--- a/crates/audio/Cargo.toml
+++ b/crates/audio/Cargo.toml
@@ -22,21 +22,12 @@ denoise = { path = "../denoise" }
 log.workspace = true
 parking_lot.workspace = true
 rodio = { workspace = true, features = [ "wav", "playback", "wav_output" ] }
-rubato = "0.16.2"
 serde.workspace = true
 settings.workspace = true
 smol.workspace = true
 thiserror.workspace = true
 util.workspace = true
 workspace-hack.workspace = true
-rand.workspace = true

 [target.'cfg(not(any(all(target_os = "windows", target_env = "gnu"), target_os = "freebsd")))'.dependencies]
 libwebrtc = { rev = "5f04705ac3f356350ae31534ffbc476abc9ea83d", git = "https://github.com/zed-industries/livekit-rust-sdks" }
-
-[dev-dependencies]
-rodio = { workspace = true, features = [ "wav", "playback", "wav_output", "noise" ] }
-gpui = { workspace = true, "features" = ["test-support"] }
-spectrum-analyzer = "1.7"
-plotly = "0.13"
-itertools.workspace = true
--- a/crates/audio/src/audio.rs
+++ b/crates/audio/src/audio.rs
@@ -1,12 +1,12 @@
 use anyhow::{Context as _, Result};
 use collections::HashMap;
 use gpui::{App, BackgroundExecutor, BorrowAppContext, Global};
+use log::info;

 #[cfg(not(any(all(target_os = "windows", target_env = "gnu"), target_os = "freebsd")))]
 mod non_windows_and_freebsd_deps {
    pub(super) use gpui::AsyncApp;
    pub(super) use libwebrtc::native::apm;
-    pub(super) use log::info;
    pub(super) use parking_lot::Mutex;
    pub(super) use rodio::cpal::Sample;
    pub(super) use rodio::source::LimitSettings;
@@ -17,10 +17,7 @@ mod non_windows_and_freebsd_deps {
 use non_windows_and_freebsd_deps::*;

 use rodio::{
-    Decoder, OutputStream, OutputStreamBuilder, Source,
-    mixer::Mixer,
-    nz,
-    source::{AutomaticGainControlSettings, Buffered},
+    Decoder, OutputStream, OutputStreamBuilder, Source, mixer::Mixer, nz, source::Buffered,
 };
 use settings::Settings;
 use std::{io::Cursor, num::NonZero, path::PathBuf, sync::atomic::Ordering, time::Duration};
@@ -29,18 +26,18 @@ use util::ResultExt;
 mod audio_settings;
 mod replays;
 mod rodio_ext;
-#[cfg(test)]
-mod test;
 pub use audio_settings::AudioSettings;
 pub use rodio_ext::RodioExt;

 use crate::audio_settings::LIVE_SETTINGS;

-// We are migrating to 44100Hz mono from 48kHz stereo. In the future once we are
-// reasonably sure most users have upgraded we will remove the LEGACY
-// parameters.
-// We migrate to 44100 because if its good for cd's its good enough for us
-pub const SAMPLE_RATE: NonZero<u32> = nz!(44100);
+// We are migrating to 16kHz sample rate from 48kHz. In the future
+// once we are reasonably sure most users have upgraded we will
+// remove the LEGACY parameters.
+//
+// We migrate to 16kHz because it is sufficient for speech and required
+// by the denoiser and future Speech to Text layers.
+pub const SAMPLE_RATE: NonZero<u32> = nz!(16000);
 pub const CHANNEL_COUNT: NonZero<u16> = nz!(1);
 pub const BUFFER_SIZE: usize = // echo canceller and livekit want 10ms of audio
    (SAMPLE_RATE.get() as usize / 100) * CHANNEL_COUNT.get() as usize;
@@ -58,6 +55,7 @@ pub fn init(cx: &mut App) {
 #[derive(Debug, Copy, Clone, Eq, Hash, PartialEq)]
 pub enum Sound {
    Joined,
+    GuestJoined,
    Leave,
    Mute,
    Unmute,
@@ -70,6 +68,7 @@ impl Sound {
    fn file(&self) -> &'static str {
        match self {
            Self::Joined => "joined_call",
+            Self::GuestJoined => "guest_joined_call",
            Self::Leave => "leave_call",
            Self::Mute => "mute",
            Self::Unmute => "unmute",
@@ -107,60 +106,49 @@ impl Default for Audio {
    }
 }

-fn automatic_gain_control_settings() -> AutomaticGainControlSettings {
-    AutomaticGainControlSettings {
-        target_level: 0.9,
-        attack_time: Duration::from_secs_f32(1f32),
-        release_time: Duration::from_secs_f32(0f32),
-        absolute_max_gain: 5.0,
-    }
-}
-
 impl Global for Audio {}

 impl Audio {
-    fn setup_mixer(&mut self) -> impl Source + use<> {
-        let (mixer, source) = rodio::mixer::mixer(CHANNEL_COUNT, SAMPLE_RATE);
-        // or the mixer will end immediately as its empty.
-        mixer.add(rodio::source::Zero::new(CHANNEL_COUNT, SAMPLE_RATE));
-        // The webrtc apm is not yet compiling for windows & freebsd
-        #[cfg(not(any(
-            any(all(target_os = "windows", target_env = "gnu")),
-            target_os = "freebsd"
-        )))]
-        let echo_canceller = Arc::clone(&self.echo_canceller);
-        #[cfg(not(any(
-            any(all(target_os = "windows", target_env = "gnu")),
-            target_os = "freebsd"
-        )))]
-        let source = source.inspect_buffer::<BUFFER_SIZE, _>(move |buffer| {
-            let mut buf: [i16; _] = buffer.map(|s| s.to_sample());
-            echo_canceller
-                .lock()
-                .process_reverse_stream(
-                    &mut buf,
-                    SAMPLE_RATE.get() as i32,
-                    CHANNEL_COUNT.get().into(),
-                )
-                .expect("Audio input and output threads should not panic");
-        });
-        self.output_mixer = Some(mixer);
-        source
-    }
-
    fn ensure_output_exists(&mut self) -> Result<&Mixer> {
        #[cfg(debug_assertions)]
        log::warn!(
            "Audio does not sound correct without optimizations. Use a release build to debug audio issues"
        );

-        if self.output_mixer.is_none() {
-            let mixer_source = self.setup_mixer();
+        if self.output_handle.is_none() {
            let output_handle = OutputStreamBuilder::open_default_stream()
                .context("Could not open default output stream")?;
            info!("Output stream: {:?}", output_handle);
-            output_handle.mixer().add(mixer_source);
            self.output_handle = Some(output_handle);
+            if let Some(output_handle) = &self.output_handle {
+                let (mixer, source) = rodio::mixer::mixer(CHANNEL_COUNT, SAMPLE_RATE);
+                // or the mixer will end immediately as its empty.
+                mixer.add(rodio::source::Zero::new(CHANNEL_COUNT, SAMPLE_RATE));
+                self.output_mixer = Some(mixer);
+
+                // The webrtc apm is not yet compiling for windows & freebsd
+                #[cfg(not(any(
+                    any(all(target_os = "windows", target_env = "gnu")),
+                    target_os = "freebsd"
+                )))]
+                let echo_canceller = Arc::clone(&self.echo_canceller);
+                #[cfg(not(any(
+                    any(all(target_os = "windows", target_env = "gnu")),
+                    target_os = "freebsd"
+                )))]
+                let source = source.inspect_buffer::<BUFFER_SIZE, _>(move |buffer| {
+                    let mut buf: [i16; _] = buffer.map(|s| s.to_sample());
+                    echo_canceller
+                        .lock()
+                        .process_reverse_stream(
+                            &mut buf,
+                            SAMPLE_RATE.get() as i32,
+                            CHANNEL_COUNT.get().into(),
+                        )
+                        .expect("Audio input and output threads should not panic");
+                });
+                output_handle.mixer().add(source);
+            }
        }

        Ok(self
@@ -176,65 +164,6 @@ impl Audio {
        self.replays.replays_to_tar(executor)
    }

-    #[cfg(not(any(all(target_os = "windows", target_env = "gnu"), target_os = "freebsd")))]
-    pub fn input_pipeline(
-        voip_parts: VoipParts,
-        raw_mic_input: impl Source,
-    ) -> anyhow::Result<impl Source> {
-        let stream = raw_mic_input
-            .possibly_disconnected_channels_to_mono()
-            .constant_samplerate(SAMPLE_RATE)
-            .limit(LimitSettings::live_performance());
-            // .process_buffer::<BUFFER_SIZE, _>(move |buffer| {
-            //     let mut int_buffer: [i16; _] = buffer.map(|s| s.to_sample());
-            //     if voip_parts
-            //         .echo_canceller
-            //         .lock()
-            //         .process_stream(
-            //             &mut int_buffer,
-            //             SAMPLE_RATE.get() as i32,
-            //             CHANNEL_COUNT.get() as i32,
-            //         )
-            //         .context("livekit audio processor error")
-            //         .log_err()
-            //         .is_some()
-            //     {
-            //         for (sample, processed) in buffer.iter_mut().zip(&int_buffer) {
-            //             *sample = (*processed).to_sample();
-            //         }
-            //     }
-            // });
-        // .denoise()
-        // .context("Could not set up denoiser")?
-        // .automatic_gain_control(automatic_gain_control_settings())
-        // .periodic_access(Duration::from_millis(100), move |agc_source| {
-        //     agc_source
-        //         .set_enabled(LIVE_SETTINGS.auto_microphone_volume.load(Ordering::Relaxed));
-        //     let denoise = agc_source.inner_mut();
-        //     denoise
-        //         .set_enabled(LIVE_SETTINGS.denoise.load(Ordering::Relaxed))
-        //         .unwrap(); // todo make this log?
-        // });
-
-        let stream = if voip_parts.legacy_audio_compatible {
-            stream.constant_params(LEGACY_CHANNEL_COUNT, LEGACY_SAMPLE_RATE)
-        } else {
-            stream.constant_params(CHANNEL_COUNT, SAMPLE_RATE)
-        };
-
-        // the audio processing module gives us half its buffer duration
-        // of empty samples. We can skip those.
-        const APM_CHUNK_DURATION: Duration = Duration::from_millis(10);
-        let stream = stream.skip_duration(APM_CHUNK_DURATION / 2);
-
-        let (replay, stream) = stream.replayable(REPLAY_DURATION)?;
-        voip_parts
-            .replays
-            .add_voip_stream("local microphone".to_string(), replay);
-
-        Ok(stream)
-    }
-
    #[cfg(not(any(all(target_os = "windows", target_env = "gnu"), target_os = "freebsd")))]
    pub fn open_microphone(voip_parts: VoipParts) -> anyhow::Result<impl Source> {
        let stream = rodio::microphone::MicrophoneBuilder::new()
@@ -243,12 +172,59 @@ impl Audio {
            .prefer_sample_rates([
                SAMPLE_RATE, // sample rates trivially resamplable to `SAMPLE_RATE`
                SAMPLE_RATE.saturating_mul(nz!(2)),
+                SAMPLE_RATE.saturating_mul(nz!(3)),
+                SAMPLE_RATE.saturating_mul(nz!(4)),
            ])
            .prefer_channel_counts([nz!(1), nz!(2), nz!(3), nz!(4)])
            .prefer_buffer_sizes(512..)
            .open_stream()?;
        info!("Opened microphone: {:?}", stream.config());
-        Self::input_pipeline(voip_parts, stream)
+
+        let stream = stream
+            .possibly_disconnected_channels_to_mono()
+            .constant_samplerate(SAMPLE_RATE)
+            .limit(LimitSettings::live_performance())
+            .process_buffer::<BUFFER_SIZE, _>(move |buffer| {
+                let mut int_buffer: [i16; _] = buffer.map(|s| s.to_sample());
+                if voip_parts
+                    .echo_canceller
+                    .lock()
+                    .process_stream(
+                        &mut int_buffer,
+                        SAMPLE_RATE.get() as i32,
+                        CHANNEL_COUNT.get() as i32,
+                    )
+                    .context("livekit audio processor error")
+                    .log_err()
+                    .is_some()
+                {
+                    for (sample, processed) in buffer.iter_mut().zip(&int_buffer) {
+                        *sample = (*processed).to_sample();
+                    }
+                }
+            })
+            .denoise()
+            .context("Could not set up denoiser")?
+            .automatic_gain_control(0.90, 1.0, 0.0, 5.0)
+            .periodic_access(Duration::from_millis(100), move |agc_source| {
+                agc_source
+                    .set_enabled(LIVE_SETTINGS.auto_microphone_volume.load(Ordering::Relaxed));
+                let denoise = agc_source.inner_mut();
+                denoise.set_enabled(LIVE_SETTINGS.denoise.load(Ordering::Relaxed));
+            });
+
+        let stream = if voip_parts.legacy_audio_compatible {
+            stream.constant_params(LEGACY_CHANNEL_COUNT, LEGACY_SAMPLE_RATE)
+        } else {
+            stream.constant_params(CHANNEL_COUNT, SAMPLE_RATE)
+        };
+
+        let (replay, stream) = stream.replayable(REPLAY_DURATION)?;
+        voip_parts
+            .replays
+            .add_voip_stream("local microphone".to_string(), replay);
+
+        Ok(stream)
    }

    pub fn play_voip_stream(
@@ -259,7 +235,7 @@ impl Audio {
    ) -> anyhow::Result<()> {
        let (replay_source, source) = source
            .constant_params(CHANNEL_COUNT, SAMPLE_RATE)
-            .automatic_gain_control(automatic_gain_control_settings())
+            .automatic_gain_control(0.90, 1.0, 0.0, 5.0)
            .periodic_access(Duration::from_millis(100), move |agc_source| {
                agc_source.set_enabled(LIVE_SETTINGS.auto_speaker_volume.load(Ordering::Relaxed));
            })
--- a/crates/audio/src/audio_settings.rs
+++ b/crates/audio/src/audio_settings.rs
@@ -42,7 +42,7 @@ pub struct AudioSettings {

 /// Configuration of audio in Zed
 impl Settings for AudioSettings {
-    fn from_settings(content: &settings::SettingsContent, _cx: &mut App) -> Self {
+    fn from_settings(content: &settings::SettingsContent) -> Self {
        let audio = &content.audio.as_ref().unwrap();
        AudioSettings {
            rodio_audio: audio.rodio_audio.unwrap(),
--- a/crates/audio/src/rodio_ext.rs
+++ b/crates/audio/src/rodio_ext.rs
@@ -1,21 +1,26 @@
-use std::{num::NonZero, time::Duration};
-
-use denoise::DenoiserError;
-use log::warn;
-use rodio::{
-    ChannelCount, Sample, SampleRate, Source, buffer::SamplesBuffer,
-    conversions::ChannelCountConverter, nz,
+use std::{
+    num::NonZero,
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicBool, Ordering},
+    },
+    time::Duration,
 };

-use crate::rodio_ext::resample::FixedResampler;
-pub use replayable::{Replay, ReplayDurationTooShort, Replayable};
-
-mod replayable;
-mod resample;
-mod resampling_denoise;
+use crossbeam::queue::ArrayQueue;
+use denoise::{Denoiser, DenoiserError};
+use log::warn;
+use rodio::{
+    ChannelCount, Sample, SampleRate, Source, conversions::SampleRateConverter, nz,
+    source::UniformSourceIterator,
+};

 const MAX_CHANNELS: usize = 8;

+#[derive(Debug, thiserror::Error)]
+#[error("Replay duration is too short must be >= 100ms")]
+pub struct ReplayDurationTooShort;
+
 // These all require constant sources (so the span is infinitely long)
 // this is not guaranteed by rodio however we know it to be true in all our
 // applications. Rodio desperately needs a constant source concept.
@@ -31,15 +36,14 @@ pub trait RodioExt: Source + Sized {
        duration: Duration,
    ) -> Result<(Replay, Replayable<Self>), ReplayDurationTooShort>;
    fn take_samples(self, n: usize) -> TakeSamples<Self>;
-    fn denoise(self) -> Result<resampling_denoise::ResamplingDenoiser<Self>, DenoiserError>;
+    fn denoise(self) -> Result<Denoiser<Self>, DenoiserError>;
    fn constant_params(
        self,
        channel_count: ChannelCount,
        sample_rate: SampleRate,
-    ) -> ConstantChannelCount<FixedResampler<Self>>;
-    fn constant_samplerate(self, sample_rate: SampleRate) -> FixedResampler<Self>;
+    ) -> UniformSourceIterator<Self>;
+    fn constant_samplerate(self, sample_rate: SampleRate) -> ConstantSampleRate<Self>;
    fn possibly_disconnected_channels_to_mono(self) -> ToMono<Self>;
-    fn into_samples_buffer(self) -> SamplesBuffer;
 }

 impl<S: Source> RodioExt for S {
@@ -77,7 +81,38 @@ impl<S: Source> RodioExt for S {
        self,
        duration: Duration,
    ) -> Result<(Replay, Replayable<Self>), ReplayDurationTooShort> {
-        replayable::replayable(self, duration)
+        if duration < Duration::from_millis(100) {
+            return Err(ReplayDurationTooShort);
+        }
+
+        let samples_per_second = self.sample_rate().get() as usize * self.channels().get() as usize;
+        let samples_to_queue = duration.as_secs_f64() * samples_per_second as f64;
+        let samples_to_queue =
+            (samples_to_queue as usize).next_multiple_of(self.channels().get().into());
+
+        let chunk_size =
+            (samples_per_second.div_ceil(10)).next_multiple_of(self.channels().get() as usize);
+        let chunks_to_queue = samples_to_queue.div_ceil(chunk_size);
+
+        let is_active = Arc::new(AtomicBool::new(true));
+        let queue = Arc::new(ReplayQueue::new(chunks_to_queue, chunk_size));
+        Ok((
+            Replay {
+                rx: Arc::clone(&queue),
+                buffer: Vec::new().into_iter(),
+                sleep_duration: duration / 2,
+                sample_rate: self.sample_rate(),
+                channel_count: self.channels(),
+                source_is_active: is_active.clone(),
+            },
+            Replayable {
+                tx: queue,
+                inner: self,
+                buffer: Vec::with_capacity(chunk_size),
+                chunk_size,
+                is_active,
+            },
+        ))
    }
    fn take_samples(self, n: usize) -> TakeSamples<S> {
        TakeSamples {
@@ -85,48 +120,45 @@ impl<S: Source> RodioExt for S {
            left_to_take: n,
        }
    }
-    fn denoise(self) -> Result<resampling_denoise::ResamplingDenoiser<Self>, DenoiserError> {
-        resampling_denoise::ResamplingDenoiser::new(self)
+    fn denoise(self) -> Result<Denoiser<Self>, DenoiserError> {
+        let res = Denoiser::try_new(self);
+        res
    }
    fn constant_params(
        self,
        channel_count: ChannelCount,
        sample_rate: SampleRate,
-    ) -> ConstantChannelCount<FixedResampler<Self>> {
-        ConstantChannelCount::new(self.constant_samplerate(sample_rate), channel_count)
+    ) -> UniformSourceIterator<Self> {
+        UniformSourceIterator::new(self, channel_count, sample_rate)
    }
-    fn constant_samplerate(self, sample_rate: SampleRate) -> FixedResampler<Self> {
-        FixedResampler::new(self, sample_rate)
+    fn constant_samplerate(self, sample_rate: SampleRate) -> ConstantSampleRate<Self> {
+        ConstantSampleRate::new(self, sample_rate)
    }
    fn possibly_disconnected_channels_to_mono(self) -> ToMono<Self> {
        ToMono::new(self)
    }
-    fn into_samples_buffer(mut self) -> SamplesBuffer {
-        let samples: Vec<_> = self.by_ref().collect();
-        SamplesBuffer::new(self.channels(), self.sample_rate(), samples)
-    }
 }

-pub struct ConstantChannelCount<S: Source> {
-    inner: ChannelCountConverter<S>,
+pub struct ConstantSampleRate<S: Source> {
+    inner: SampleRateConverter<S>,
    channels: ChannelCount,
    sample_rate: SampleRate,
 }

-impl<S: Source> ConstantChannelCount<S> {
-    pub fn new(source: S, target_channels: ChannelCount) -> Self {
-        let input_channels = source.channels();
-        let sample_rate = source.sample_rate();
-        let inner = ChannelCountConverter::new(source, input_channels, target_channels);
+impl<S: Source> ConstantSampleRate<S> {
+    fn new(source: S, target_rate: SampleRate) -> Self {
+        let input_sample_rate = source.sample_rate();
+        let channels = source.channels();
+        let inner = SampleRateConverter::new(source, input_sample_rate, target_rate, channels);
        Self {
-            sample_rate,
            inner,
-            channels: target_channels,
+            channels,
+            sample_rate: target_rate,
        }
    }
 }

-impl<S: Source> Iterator for ConstantChannelCount<S> {
+impl<S: Source> Iterator for ConstantSampleRate<S> {
    type Item = rodio::Sample;

    fn next(&mut self) -> Option<Self::Item> {
@@ -138,7 +170,7 @@ impl<S: Source> Iterator for ConstantChannelCount<S> {
    }
 }

-impl<S: Source> Source for ConstantChannelCount<S> {
+impl<S: Source> Source for ConstantSampleRate<S> {
    fn current_span_len(&self) -> Option<usize> {
        None
    }
@@ -236,15 +268,6 @@ pub struct TakeSamples<S> {
    left_to_take: usize,
 }

-impl<S: Clone> Clone for TakeSamples<S> {
-    fn clone(&self) -> Self {
-        Self {
-            inner: self.inner.clone(),
-            left_to_take: self.left_to_take,
-        }
-    }
-}
-
 impl<S: Source> Iterator for TakeSamples<S> {
    type Item = Sample;

@@ -284,6 +307,53 @@ impl<S: Source> Source for TakeSamples<S> {
    }
 }

+/// constant source, only works on a single span
+#[derive(Debug)]
+struct ReplayQueue {
+    inner: ArrayQueue<Vec<Sample>>,
+    normal_chunk_len: usize,
+    /// The last chunk in the queue may be smaller than
+    /// the normal chunk size. This is always equal to the
+    /// size of the last element in the queue.
+    /// (so normally chunk_size)
+    last_chunk: Mutex<Vec<Sample>>,
+}
+
+impl ReplayQueue {
+    fn new(queue_len: usize, chunk_size: usize) -> Self {
+        Self {
+            inner: ArrayQueue::new(queue_len),
+            normal_chunk_len: chunk_size,
+            last_chunk: Mutex::new(Vec::new()),
+        }
+    }
+    /// Returns the length in samples
+    fn len(&self) -> usize {
+        self.inner.len().saturating_sub(1) * self.normal_chunk_len
+            + self
+                .last_chunk
+                .lock()
+                .expect("Self::push_last can not poison this lock")
+                .len()
+    }
+
+    fn pop(&self) -> Option<Vec<Sample>> {
+        self.inner.pop() // removes element that was inserted first
+    }
+
+    fn push_last(&self, mut samples: Vec<Sample>) {
+        let mut last_chunk = self
+            .last_chunk
+            .lock()
+            .expect("Self::len can not poison this lock");
+        std::mem::swap(&mut *last_chunk, &mut samples);
+    }
+
+    fn push_normal(&self, samples: Vec<Sample>) {
+        let _pushed_out_of_ringbuf = self.inner.force_push(samples);
+    }
+}
+
 /// constant source, only works on a single span
 pub struct ProcessBuffer<const N: usize, S, F>
 where
@@ -417,15 +487,147 @@ where
    }
 }

+/// constant source, only works on a single span
+#[derive(Debug)]
+pub struct Replayable<S: Source> {
+    inner: S,
+    buffer: Vec<Sample>,
+    chunk_size: usize,
+    tx: Arc<ReplayQueue>,
+    is_active: Arc<AtomicBool>,
+}
+
+impl<S: Source> Iterator for Replayable<S> {
+    type Item = Sample;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(sample) = self.inner.next() {
+            self.buffer.push(sample);
+            // If the buffer is full send it
+            if self.buffer.len() == self.chunk_size {
+                self.tx.push_normal(std::mem::take(&mut self.buffer));
+            }
+            Some(sample)
+        } else {
+            let last_chunk = std::mem::take(&mut self.buffer);
+            self.tx.push_last(last_chunk);
+            self.is_active.store(false, Ordering::Relaxed);
+            None
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.inner.size_hint()
+    }
+}
+
+impl<S: Source> Source for Replayable<S> {
+    fn current_span_len(&self) -> Option<usize> {
+        self.inner.current_span_len()
+    }
+
+    fn channels(&self) -> ChannelCount {
+        self.inner.channels()
+    }
+
+    fn sample_rate(&self) -> SampleRate {
+        self.inner.sample_rate()
+    }
+
+    fn total_duration(&self) -> Option<Duration> {
+        self.inner.total_duration()
+    }
+}
+
+/// constant source, only works on a single span
+#[derive(Debug)]
+pub struct Replay {
+    rx: Arc<ReplayQueue>,
+    buffer: std::vec::IntoIter<Sample>,
+    sleep_duration: Duration,
+    sample_rate: SampleRate,
+    channel_count: ChannelCount,
+    source_is_active: Arc<AtomicBool>,
+}
+
+impl Replay {
+    pub fn source_is_active(&self) -> bool {
+        // - source could return None and not drop
+        // - source could be dropped before returning None
+        self.source_is_active.load(Ordering::Relaxed) && Arc::strong_count(&self.rx) < 2
+    }
+
+    /// Duration of what is in the buffer and can be returned without blocking.
+    pub fn duration_ready(&self) -> Duration {
+        let samples_per_second = self.channels().get() as u32 * self.sample_rate().get();
+
+        let seconds_queued = self.samples_ready() as f64 / samples_per_second as f64;
+        Duration::from_secs_f64(seconds_queued)
+    }
+
+    /// Number of samples in the buffer and can be returned without blocking.
+    pub fn samples_ready(&self) -> usize {
+        self.rx.len() + self.buffer.len()
+    }
+}
+
+impl Iterator for Replay {
+    type Item = Sample;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(sample) = self.buffer.next() {
+            return Some(sample);
+        }
+
+        loop {
+            if let Some(new_buffer) = self.rx.pop() {
+                self.buffer = new_buffer.into_iter();
+                return self.buffer.next();
+            }
+
+            if !self.source_is_active() {
+                return None;
+            }
+
+            // The queue does not support blocking on a next item. We want this queue as it
+            // is quite fast and provides a fixed size. We know how many samples are in a
+            // buffer so if we do not get one now we must be getting one after `sleep_duration`.
+            std::thread::sleep(self.sleep_duration);
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        ((self.rx.len() + self.buffer.len()), None)
+    }
+}
+
+impl Source for Replay {
+    fn current_span_len(&self) -> Option<usize> {
+        None // source is not compatible with spans
+    }
+
+    fn channels(&self) -> ChannelCount {
+        self.channel_count
+    }
+
+    fn sample_rate(&self) -> SampleRate {
+        self.sample_rate
+    }
+
+    fn total_duration(&self) -> Option<Duration> {
+        None
+    }
+}
+
 #[cfg(test)]
 mod tests {
    use rodio::{nz, static_buffer::StaticSamplesBuffer};

    use super::*;

-    pub const SAMPLES: [Sample; 5] = [0.0, 1.0, 2.0, 3.0, 4.0];
+    const SAMPLES: [Sample; 5] = [0.0, 1.0, 2.0, 3.0, 4.0];

-    pub fn test_source() -> StaticSamplesBuffer {
+    fn test_source() -> StaticSamplesBuffer {
        StaticSamplesBuffer::new(nz!(1), nz!(1), &SAMPLES)
    }

@@ -488,4 +690,74 @@ mod tests {
            assert_eq!(yielded, SAMPLES.len())
        }
    }
+
+    mod instant_replay {
+        use super::*;
+
+        #[test]
+        fn continues_after_history() {
+            let input = test_source();
+
+            let (mut replay, mut source) = input
+                .replayable(Duration::from_secs(3))
+                .expect("longer than 100ms");
+
+            source.by_ref().take(3).count();
+            let yielded: Vec<Sample> = replay.by_ref().take(3).collect();
+            assert_eq!(&yielded, &SAMPLES[0..3],);
+
+            source.count();
+            let yielded: Vec<Sample> = replay.collect();
+            assert_eq!(&yielded, &SAMPLES[3..5],);
+        }
+
+        #[test]
+        fn keeps_only_latest() {
+            let input = test_source();
+
+            let (mut replay, mut source) = input
+                .replayable(Duration::from_secs(2))
+                .expect("longer than 100ms");
+
+            source.by_ref().take(5).count(); // get all items but do not end the source
+            let yielded: Vec<Sample> = replay.by_ref().take(2).collect();
+            assert_eq!(&yielded, &SAMPLES[3..5]);
+            source.count(); // exhaust source
+            assert_eq!(replay.next(), None);
+        }
+
+        #[test]
+        fn keeps_correct_amount_of_seconds() {
+            let input = StaticSamplesBuffer::new(nz!(1), nz!(16_000), &[0.0; 40_000]);
+
+            let (replay, mut source) = input
+                .replayable(Duration::from_secs(2))
+                .expect("longer than 100ms");
+
+            // exhaust but do not yet end source
+            source.by_ref().take(40_000).count();
+
+            // take all samples we can without blocking
+            let ready = replay.samples_ready();
+            let n_yielded = replay.take_samples(ready).count();
+
+            let max = source.sample_rate().get() * source.channels().get() as u32 * 2;
+            let margin = 16_000 / 10; // 100ms
+            assert!(n_yielded as u32 >= max - margin);
+        }
+
+        #[test]
+        fn samples_ready() {
+            let input = StaticSamplesBuffer::new(nz!(1), nz!(16_000), &[0.0; 40_000]);
+            let (mut replay, source) = input
+                .replayable(Duration::from_secs(2))
+                .expect("longer than 100ms");
+            assert_eq!(replay.by_ref().samples_ready(), 0);
+
+            source.take(8000).count(); // half a second
+            let margin = 16_000 / 10; // 100ms
+            let ready = replay.samples_ready();
+            assert!(ready >= 8000 - margin);
+        }
+    }
 }
--- a/crates/audio/src/rodio_ext/replayable.rs
+++ b/crates/audio/src/rodio_ext/replayable.rs
@@ -1,308 +0,0 @@
-use std::{
-    sync::{
-        Arc, Mutex,
-        atomic::{AtomicBool, Ordering},
-    },
-    time::Duration,
-};
-
-use crossbeam::queue::ArrayQueue;
-use rodio::{ChannelCount, Sample, SampleRate, Source};
-
-#[derive(Debug, thiserror::Error)]
-#[error("Replay duration is too short must be >= 100ms")]
-pub struct ReplayDurationTooShort;
-
-pub fn replayable<S: Source>(
-    source: S,
-    duration: Duration,
-) -> Result<(Replay, Replayable<S>), ReplayDurationTooShort> {
-    if duration < Duration::from_millis(100) {
-        return Err(ReplayDurationTooShort);
-    }
-
-    let samples_per_second = source.sample_rate().get() as usize * source.channels().get() as usize;
-    let samples_to_queue = duration.as_secs_f64() * samples_per_second as f64;
-    let samples_to_queue =
-        (samples_to_queue as usize).next_multiple_of(source.channels().get().into());
-
-    let chunk_size =
-        (samples_per_second.div_ceil(10)).next_multiple_of(source.channels().get() as usize);
-    let chunks_to_queue = samples_to_queue.div_ceil(chunk_size);
-
-    let is_active = Arc::new(AtomicBool::new(true));
-    let queue = Arc::new(ReplayQueue::new(chunks_to_queue, chunk_size));
-    Ok((
-        Replay {
-            rx: Arc::clone(&queue),
-            buffer: Vec::new().into_iter(),
-            sleep_duration: duration / 2,
-            sample_rate: source.sample_rate(),
-            channel_count: source.channels(),
-            source_is_active: is_active.clone(),
-        },
-        Replayable {
-            tx: queue,
-            inner: source,
-            buffer: Vec::with_capacity(chunk_size),
-            chunk_size,
-            is_active,
-        },
-    ))
-}
-
-/// constant source, only works on a single span
-#[derive(Debug)]
-struct ReplayQueue {
-    inner: ArrayQueue<Vec<Sample>>,
-    normal_chunk_len: usize,
-    /// The last chunk in the queue may be smaller than
-    /// the normal chunk size. This is always equal to the
-    /// size of the last element in the queue.
-    /// (so normally chunk_size)
-    last_chunk: Mutex<Vec<Sample>>,
-}
-
-impl ReplayQueue {
-    fn new(queue_len: usize, chunk_size: usize) -> Self {
-        Self {
-            inner: ArrayQueue::new(queue_len),
-            normal_chunk_len: chunk_size,
-            last_chunk: Mutex::new(Vec::new()),
-        }
-    }
-    /// Returns the length in samples
-    fn len(&self) -> usize {
-        self.inner.len().saturating_sub(1) * self.normal_chunk_len
-            + self
-                .last_chunk
-                .lock()
-                .expect("Self::push_last can not poison this lock")
-                .len()
-    }
-
-    fn pop(&self) -> Option<Vec<Sample>> {
-        self.inner.pop() // removes element that was inserted first
-    }
-
-    fn push_last(&self, mut samples: Vec<Sample>) {
-        let mut last_chunk = self
-            .last_chunk
-            .lock()
-            .expect("Self::len can not poison this lock");
-        std::mem::swap(&mut *last_chunk, &mut samples);
-    }
-
-    fn push_normal(&self, samples: Vec<Sample>) {
-        let _pushed_out_of_ringbuf = self.inner.force_push(samples);
-    }
-}
-
-/// constant source, only works on a single span
-#[derive(Debug)]
-pub struct Replayable<S: Source> {
-    inner: S,
-    buffer: Vec<Sample>,
-    chunk_size: usize,
-    tx: Arc<ReplayQueue>,
-    is_active: Arc<AtomicBool>,
-}
-
-impl<S: Source> Iterator for Replayable<S> {
-    type Item = Sample;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if let Some(sample) = self.inner.next() {
-            self.buffer.push(sample);
-            // If the buffer is full send it
-            if self.buffer.len() == self.chunk_size {
-                self.tx.push_normal(std::mem::take(&mut self.buffer));
-            }
-            Some(sample)
-        } else {
-            let last_chunk = std::mem::take(&mut self.buffer);
-            self.tx.push_last(last_chunk);
-            self.is_active.store(false, Ordering::Relaxed);
-            None
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.inner.size_hint()
-    }
-}
-
-impl<S: Source> Source for Replayable<S> {
-    fn current_span_len(&self) -> Option<usize> {
-        self.inner.current_span_len()
-    }
-
-    fn channels(&self) -> ChannelCount {
-        self.inner.channels()
-    }
-
-    fn sample_rate(&self) -> SampleRate {
-        self.inner.sample_rate()
-    }
-
-    fn total_duration(&self) -> Option<Duration> {
-        self.inner.total_duration()
-    }
-}
-
-/// constant source, only works on a single span
-#[derive(Debug)]
-pub struct Replay {
-    rx: Arc<ReplayQueue>,
-    buffer: std::vec::IntoIter<Sample>,
-    sleep_duration: Duration,
-    sample_rate: SampleRate,
-    channel_count: ChannelCount,
-    source_is_active: Arc<AtomicBool>,
-}
-
-impl Replay {
-    pub fn source_is_active(&self) -> bool {
-        // - source could return None and not drop
-        // - source could be dropped before returning None
-        self.source_is_active.load(Ordering::Relaxed) && Arc::strong_count(&self.rx) < 2
-    }
-
-    /// Duration of what is in the buffer and can be returned without blocking.
-    pub fn duration_ready(&self) -> Duration {
-        let samples_per_second = self.channels().get() as u32 * self.sample_rate().get();
-
-        let seconds_queued = self.samples_ready() as f64 / samples_per_second as f64;
-        Duration::from_secs_f64(seconds_queued)
-    }
-
-    /// Number of samples in the buffer and can be returned without blocking.
-    pub fn samples_ready(&self) -> usize {
-        self.rx.len() + self.buffer.len()
-    }
-}
-
-impl Iterator for Replay {
-    type Item = Sample;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if let Some(sample) = self.buffer.next() {
-            return Some(sample);
-        }
-
-        loop {
-            if let Some(new_buffer) = self.rx.pop() {
-                self.buffer = new_buffer.into_iter();
-                return self.buffer.next();
-            }
-
-            if !self.source_is_active() {
-                return None;
-            }
-
-            // The queue does not support blocking on a next item. We want this queue as it
-            // is quite fast and provides a fixed size. We know how many samples are in a
-            // buffer so if we do not get one now we must be getting one after `sleep_duration`.
-            std::thread::sleep(self.sleep_duration);
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        ((self.rx.len() + self.buffer.len()), None)
-    }
-}
-
-impl Source for Replay {
-    fn current_span_len(&self) -> Option<usize> {
-        None // source is not compatible with spans
-    }
-
-    fn channels(&self) -> ChannelCount {
-        self.channel_count
-    }
-
-    fn sample_rate(&self) -> SampleRate {
-        self.sample_rate
-    }
-
-    fn total_duration(&self) -> Option<Duration> {
-        None
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use rodio::{nz, static_buffer::StaticSamplesBuffer};
-
-    use super::*;
-    use crate::{
-        RodioExt,
-        rodio_ext::tests::{SAMPLES, test_source},
-    };
-
-    #[test]
-    fn continues_after_history() {
-        let input = test_source();
-
-        let (mut replay, mut source) = input
-            .replayable(Duration::from_secs(3))
-            .expect("longer than 100ms");
-
-        source.by_ref().take(3).count();
-        let yielded: Vec<Sample> = replay.by_ref().take(3).collect();
-        assert_eq!(&yielded, &SAMPLES[0..3],);
-
-        source.count();
-        let yielded: Vec<Sample> = replay.collect();
-        assert_eq!(&yielded, &SAMPLES[3..5],);
-    }
-
-    #[test]
-    fn keeps_only_latest() {
-        let input = test_source();
-
-        let (mut replay, mut source) = input
-            .replayable(Duration::from_secs(2))
-            .expect("longer than 100ms");
-
-        source.by_ref().take(5).count(); // get all items but do not end the source
-        let yielded: Vec<Sample> = replay.by_ref().take(2).collect();
-        assert_eq!(&yielded, &SAMPLES[3..5]);
-        source.count(); // exhaust source
-        assert_eq!(replay.next(), None);
-    }
-
-    #[test]
-    fn keeps_correct_amount_of_seconds() {
-        let input = StaticSamplesBuffer::new(nz!(1), nz!(16_000), &[0.0; 40_000]);
-
-        let (replay, mut source) = input
-            .replayable(Duration::from_secs(2))
-            .expect("longer than 100ms");
-
-        // exhaust but do not yet end source
-        source.by_ref().take(40_000).count();
-
-        // take all samples we can without blocking
-        let ready = replay.samples_ready();
-        let n_yielded = replay.take_samples(ready).count();
-
-        let max = source.sample_rate().get() * source.channels().get() as u32 * 2;
-        let margin = 16_000 / 10; // 100ms
-        assert!(n_yielded as u32 >= max - margin);
-    }
-
-    #[test]
-    fn samples_ready() {
-        let input = StaticSamplesBuffer::new(nz!(1), nz!(16_000), &[0.0; 40_000]);
-        let (mut replay, source) = input
-            .replayable(Duration::from_secs(2))
-            .expect("longer than 100ms");
-        assert_eq!(replay.by_ref().samples_ready(), 0);
-
-        source.take(8000).count(); // half a second
-        let margin = 16_000 / 10; // 100ms
-        let ready = replay.samples_ready();
-        assert!(ready >= 8000 - margin);
-    }
-}
--- a/crates/audio/src/rodio_ext/resample.rs
+++ b/crates/audio/src/rodio_ext/resample.rs
@@ -1,322 +0,0 @@
-use std::time::Duration;
-
-use rodio::{Sample, SampleRate, Source};
-use rubato::{FftFixedInOut, Resampler};
-
-pub struct FixedResampler<S> {
-    input: S,
-    next_channel: usize,
-    next_frame: usize,
-    output_buffer: Vec<Vec<Sample>>,
-    input_buffer: Vec<Vec<Sample>>,
-    target_sample_rate: SampleRate,
-    resampler: FftFixedInOut<Sample>,
-}
-
-impl<S: Source> FixedResampler<S> {
-    pub fn new(input: S, target_sample_rate: SampleRate) -> Self {
-        let chunk_size_in =
-            Duration::from_millis(50).as_secs_f32() * input.sample_rate().get() as f32;
-        let chunk_size_in = chunk_size_in.ceil() as usize;
-
-        let resampler = FftFixedInOut::new(
-            input.sample_rate().get() as usize,
-            target_sample_rate.get() as usize,
-            chunk_size_in,
-            input.channels().get() as usize,
-        )
-        .expect(
-            "sample rates are non zero, and we are not changing it so there is no resample ratio",
-        );
-
-        let mut this = Self {
-            next_channel: 0,
-            next_frame: 0,
-            output_buffer: resampler.output_buffer_allocate(true),
-            input_buffer: resampler.input_buffer_allocate(false),
-            target_sample_rate,
-            resampler,
-            input,
-        };
-        this.bootstrap();
-        this
-    }
-
-    pub fn into_inner(self) -> S {
-        self.input
-    }
-
-    fn bootstrap(&mut self) -> Option<()> {
-        for _ in 0..self.resampler.input_frames_next() {
-            for input_channel in &mut self.input_buffer {
-                input_channel.push(self.input.next()?);
-            }
-        }
-
-        let (input_frames, output_frames) = self.resampler
-            .process_into_buffer(&mut self.input_buffer, &mut self.output_buffer, None).expect("Input and output buffer channels are correct as they have been set by the resampler. The buffer for each channel is the same length. The buffer length is what is requested the resampler.");
-
-        debug_assert_eq!(input_frames, self.input_buffer[0].len());
-        debug_assert_eq!(output_frames, self.output_buffer[0].len());
-
-        self.next_frame = self.resampler.output_delay();
-        self.next_channel = 0;
-        Some(())
-    }
-
-    #[cold]
-    fn resample_buffer(&mut self) -> Option<()> {
-        for input_channel in &mut self.input_buffer {
-            input_channel.clear();
-        }
-
-        for _ in 0..self.resampler.input_frames_next() {
-            for input_channel in &mut self.input_buffer {
-                input_channel.push(self.input.next()?);
-            }
-        }
-
-        let (input_frames, output_frames) = self.resampler
-            .process_into_buffer(&mut self.input_buffer, &mut self.output_buffer, None).expect("Input and output buffer channels are correct as they have been set by the resampler. The buffer for each channel is the same length. The buffer length is what is requested the resampler.");
-
-        debug_assert_eq!(input_frames, self.input_buffer[0].len());
-        debug_assert_eq!(output_frames, self.output_buffer[0].len());
-
-        self.next_frame = 0;
-        self.next_channel = 0;
-
-        Some(())
-    }
-}
-
-impl<S: Source> Source for FixedResampler<S> {
-    fn current_span_len(&self) -> Option<usize> {
-        None
-    }
-
-    fn channels(&self) -> rodio::ChannelCount {
-        self.input.channels()
-    }
-
-    fn sample_rate(&self) -> rodio::SampleRate {
-        self.target_sample_rate
-    }
-
-    fn total_duration(&self) -> Option<std::time::Duration> {
-        self.input.total_duration()
-    }
-}
-
-impl<S: Source> FixedResampler<S> {
-    fn next_sample(&mut self) -> Option<Sample> {
-        let sample = self.output_buffer[self.next_channel]
-            .get(self.next_frame)
-            .copied();
-
-        if self.next_channel < (self.input.channels().get() - 1) as usize {
-            self.next_channel += 1;
-        } else {
-            self.next_channel = 0;
-            self.next_frame += 1;
-        }
-
-        sample
-    }
-}
-
-impl<S: Source> Iterator for FixedResampler<S> {
-    type Item = Sample;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if let Some(sample) = self.next_sample() {
-            return Some(sample);
-        }
-
-        self.resample_buffer()?;
-        self.next_sample()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::time::Duration;
-
-    use crate::{
-        test::{recording_of_voice, sine},
-        RodioExt,
-    };
-    use itertools::Itertools;
-    use rodio::{nz, Source};
-    use spectrum_analyzer::{scaling::divide_by_N_sqrt, FrequencyLimit};
-
-    #[derive(Debug)]
-    struct PeakPitch {
-        pub median: f32,
-        pub error: f32,
-    }
-
-    fn assert_non_zero_volume_fuzzy(source: impl Source) {
-        let sample_rate = source.sample_rate();
-        let chunk_size = sample_rate.get() / 1000;
-        let ms_volume = source.into_iter().chunks(chunk_size as usize);
-        let ms_volume = ms_volume
-            .into_iter()
-            .map(|chunk| chunk.into_iter().map(|s| s.abs()).sum::<f32>() / chunk_size as f32);
-
-        for (millis, volume) in ms_volume.enumerate() {
-            assert!(
-                volume > 0.01,
-                "Volume about zero around {:?}",
-                Duration::from_millis(millis as u64)
-            )
-        }
-    }
-
-    fn median_peak_pitch(source: impl Source) -> PeakPitch {
-        use spectrum_analyzer::{samples_fft_to_spectrum, windows::hann_window};
-
-        let channels = source.channels().get();
-        let sample_rate = source.sample_rate().get();
-        let nyquist_freq = (sample_rate / 2) as f32;
-        let hundred_millis: usize = usize::try_from(sample_rate / 10)
-            .unwrap()
-            .next_power_of_two();
-
-        // de-interleave (take channel 0)
-        let samples: Vec<_> = source.step_by(channels as usize).collect();
-        let mut resolution = 0f32;
-        let mut peaks = samples
-            .chunks_exact(hundred_millis)
-            .map(|chunk| {
-                let spectrum = samples_fft_to_spectrum(
-                    &hann_window(chunk),
-                    sample_rate,
-                    // only care about the human audible range (sorry bats)
-                    // (resamplers can include artifacts outside this range
-                    // we do not care about since we wont hear them anyway)
-                    FrequencyLimit::Range(20f32, 20_000f32.min(nyquist_freq)),
-                    Some(&divide_by_N_sqrt),
-                )
-                .unwrap();
-
-                resolution = resolution.max(spectrum.frequency_resolution());
-                spectrum.max().0
-            })
-            .collect_vec();
-
-        peaks.sort();
-        let median = peaks[peaks.len() / 2].val();
-        PeakPitch {
-            median,
-            error: resolution,
-        }
-    }
-
-    #[test]
-    fn constant_samplerate_preserves_length() {
-        let test_signal = recording_of_voice(nz!(3), nz!(48_000));
-        let resampled = test_signal.clone().constant_samplerate(nz!(16_000));
-
-        let diff_in_length = test_signal
-            .total_duration()
-            .unwrap()
-            .abs_diff(resampled.total_duration().unwrap());
-        assert!(diff_in_length.as_secs_f32() < 0.1)
-    }
-
-    #[test]
-    fn stereo_gets_preserved() {
-        use rodio::{
-            buffer::SamplesBuffer,
-            source::{Function, SignalGenerator},
-        };
-
-        let sample_rate = nz!(48_000);
-        let sample_rate_resampled = nz!(16_000);
-        let frequency_0 = 550f32;
-        let frequency_1 = 330f32;
-
-        let channel0 = SignalGenerator::new(sample_rate, frequency_0, Function::Sine)
-            .take_duration(Duration::from_secs(1));
-        let channel1 = SignalGenerator::new(sample_rate, frequency_1, Function::Sine)
-            .take_duration(Duration::from_secs(1));
-
-        let source = channel0.interleave(channel1).collect_vec();
-        let source = SamplesBuffer::new(nz!(2), sample_rate, source);
-        let resampled = source
-            .clone()
-            .constant_samplerate(sample_rate_resampled)
-            .collect_vec();
-
-        let (channel0_resampled, channel1_resampled): (Vec<_>, Vec<_>) = resampled
-            .chunks_exact(2)
-            .map(|s| TryInto::<[_; 2]>::try_into(s).unwrap())
-            .map(|[channel0, channel1]| (channel0, channel1))
-            .unzip();
-
-        for (resampled, frequency) in [
-            (channel0_resampled, frequency_0),
-            (channel1_resampled, frequency_1),
-        ] {
-            let resampled = SamplesBuffer::new(nz!(1), sample_rate_resampled, resampled);
-            let peak_pitch = median_peak_pitch(resampled);
-            assert!(
-                (peak_pitch.median - frequency).abs() < peak_pitch.error,
-                "pitch should be {frequency} but was {peak_pitch:?}"
-            )
-        }
-    }
-
-    #[test]
-    fn resampler_does_not_add_any_latency() {
-        let resampled = sine(nz!(1), nz!(48_000))
-            .clone()
-            .constant_samplerate(nz!(16_000))
-            .into_samples_buffer();
-        assert_non_zero_volume_fuzzy(resampled);
-    }
-
-    #[cfg(test)]
-    mod constant_samplerate_preserves_pitch {
-        use crate::test::sine;
-
-        use super::*;
-
-        #[test]
-        fn one_channel() {
-            let test_signal = sine(nz!(1), nz!(48_000));
-            rodio::wav_to_file(test_signal.clone(), "test_signal2.wav").unwrap();
-            let resampled = test_signal
-                .clone()
-                .constant_samplerate(nz!(16_000))
-                .into_samples_buffer();
-            rodio::wav_to_file(resampled.clone(), "resampled2.wav").unwrap();
-
-            let peak_pitch_before = median_peak_pitch(test_signal);
-            let peak_pitch_after = median_peak_pitch(resampled);
-
-            assert!(
-                (peak_pitch_before.median - peak_pitch_after.median).abs()
-                    < peak_pitch_before.error.max(peak_pitch_after.error),
-                "peak pitch_before: {peak_pitch_before:?}, peak pitch_after: {peak_pitch_after:?}"
-            );
-        }
-
-        #[test]
-        fn two_channel() {
-            let test_signal = sine(nz!(2), nz!(48_000));
-            let resampled = test_signal
-                .clone()
-                .constant_samplerate(nz!(16_000))
-                .into_samples_buffer();
-
-            let peak_pitch_before = median_peak_pitch(test_signal);
-            let peak_pitch_after = median_peak_pitch(resampled);
-            assert!(
-                (peak_pitch_before.median - peak_pitch_after.median).abs()
-                    < peak_pitch_before.error.max(peak_pitch_after.error),
-                "peak pitch_before: {peak_pitch_before:?}, peak pitch_after: {peak_pitch_after:?}"
-            );
-        }
-    }
-}
--- a/crates/audio/src/rodio_ext/resampling_denoise.rs
+++ b/crates/audio/src/rodio_ext/resampling_denoise.rs
@@ -1,93 +0,0 @@
-use denoise::{Denoiser, DenoiserError};
-use rodio::Sample;
-use std::time::Duration;
-
-use super::RodioExt;
-use super::resample::FixedResampler;
-use rodio::ChannelCount;
-use rodio::SampleRate;
-use rodio::Source;
-
-#[derive(Default)]
-enum InnerRSD<S: Source> {
-    Transparent(S),
-    Denoised(FixedResampler<Denoiser<FixedResampler<S>>>),
-    #[default]
-    ShouldNotExist,
-}
-
-pub struct ResamplingDenoiser<S: Source> {
-    inner: InnerRSD<S>,
-}
-
-impl<S: Source> ResamplingDenoiser<S> {
-    pub fn new(source: S) -> Result<Self, DenoiserError> {
-        Ok(ResamplingDenoiser {
-            inner: InnerRSD::Transparent(source),
-        })
-    }
-    pub fn set_enabled(&mut self, enabled: bool) -> Result<(), DenoiserError> {
-        self.inner = match std::mem::take(&mut self.inner) {
-            InnerRSD::Transparent(s) => {
-                if enabled {
-                    let sr = s.sample_rate();
-                    InnerRSD::Denoised(
-                        Denoiser::try_new(s.constant_samplerate(denoise::SUPPORTED_SAMPLE_RATE))?
-                            .constant_samplerate(sr),
-                    )
-                } else {
-                    InnerRSD::Transparent(s)
-                }
-            }
-            InnerRSD::Denoised(s) => {
-                if !enabled {
-                    InnerRSD::Transparent(s.into_inner().into_inner().into_inner())
-                } else {
-                    InnerRSD::Denoised(s)
-                }
-            }
-            InnerRSD::ShouldNotExist => unreachable!(),
-        };
-        Ok(())
-    }
-}
-
-impl<S: Source> Source for ResamplingDenoiser<S> {
-    fn current_span_len(&self) -> Option<usize> {
-        None
-    }
-
-    fn channels(&self) -> ChannelCount {
-        match &self.inner {
-            // Different types, can't unify :c
-            InnerRSD::Transparent(s) => s.channels(),
-            InnerRSD::Denoised(s) => s.channels(),
-            InnerRSD::ShouldNotExist => unreachable!(),
-        }
-    }
-
-    fn sample_rate(&self) -> SampleRate {
-        match &self.inner {
-            // Different types, can't unify :c
-            InnerRSD::Transparent(s) => s.sample_rate(),
-            InnerRSD::Denoised(s) => s.sample_rate(),
-            InnerRSD::ShouldNotExist => unreachable!(),
-        }
-    }
-
-    fn total_duration(&self) -> Option<Duration> {
-        None
-    }
-}
-
-impl<S: Source> Iterator for ResamplingDenoiser<S> {
-    type Item = Sample;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match &mut self.inner {
-            InnerRSD::Denoised(denoiser) => denoiser.next(),
-            InnerRSD::Transparent(source) => source.next(),
-            InnerRSD::ShouldNotExist => unreachable!(),
-        }
-    }
-}
--- a/crates/audio/src/test.rs
+++ b/crates/audio/src/test.rs
@@ -1,495 +0,0 @@
-//! A complex end to end audio test comparing audio features like fft spectrum
-//! of a signal before and after going through the audio pipeline
-
-use std::env::current_dir;
-use std::io::Cursor;
-use std::iter;
-use std::ops::Range;
-use std::sync::atomic::Ordering;
-use std::time::Duration;
-
-use gpui::BorrowAppContext;
-use plotly::layout::Axis;
-use rand::SeedableRng;
-use rand::rngs::SmallRng;
-use rodio::{ChannelCount, Decoder, SampleRate, mixer, nz, wav_to_file};
-use rodio::{Source, buffer::SamplesBuffer};
-use spectrum_analyzer::scaling::divide_by_N_sqrt;
-use spectrum_analyzer::windows::{self, hann_window};
-use spectrum_analyzer::{FrequencyLimit, FrequencySpectrum, samples_fft_to_spectrum};
-
-use crate::audio_settings::LIVE_SETTINGS;
-use crate::test::detector::BasicVoiceDetector;
-use crate::{Audio, LEGACY_CHANNEL_COUNT, LEGACY_SAMPLE_RATE, RodioExt, VoipParts};
-
-mod detector;
-// in hz
-const HUMAN_SPEECH_RANGE: Range<f32> = 90.0..260.0;
-
-#[gpui::test]
-fn test_input_pipeline(cx: &mut gpui::TestAppContext) {
-    // strange params to invite bugs to show themselves
-    let test_signal = recording_of_voice(nz!(3), nz!(48_000));
-    let test_signal_duration = test_signal
-        .total_duration()
-        .expect("recordings have a length");
-
-    let voip_parts = VoipParts::new(&cx.to_async()).unwrap();
-    LIVE_SETTINGS.denoise.store(false, Ordering::Relaxed);
-    let input = Audio::input_pipeline(voip_parts, test_signal.clone()).unwrap();
-
-    let input_pipeline = input
-        .take_duration(test_signal_duration)
-        .into_samples_buffer();
-
-    let expected_output =
-        recording_of_voice(input_pipeline.channels(), input_pipeline.sample_rate());
-
-    rodio::wav_to_file(
-        BasicVoiceDetector::add_voice_activity_as_channel(input_pipeline.clone()),
-        "input_pipeline_output.wav",
-    )
-    .unwrap();
-    rodio::wav_to_file(
-        BasicVoiceDetector::add_voice_activity_as_channel(expected_output.clone()),
-        "input_pipeline_expect.wav",
-    )
-    .unwrap();
-    assert_similar_voice_spectra(expected_output, input_pipeline);
-}
-
-#[gpui::test]
-fn test_output_pipeline(cx: &mut gpui::TestAppContext) {
-    let test_signal = recording_of_voice(LEGACY_CHANNEL_COUNT, LEGACY_SAMPLE_RATE);
-    let test_signal_duration = test_signal
-        .total_duration()
-        .expect("recordings have a length");
-
-    let audio_output =
-        cx.update(|cx| cx.update_default_global::<Audio, _>(|audio, _| audio.setup_mixer()));
-
-    cx.update(|cx| {
-        Audio::play_voip_stream(test_signal.clone(), "test".to_string(), true, cx).unwrap()
-    });
-
-    let output_pipeline = audio_output
-        .take_duration(test_signal_duration)
-        .into_samples_buffer();
-
-    // dont care about the channel count and sample rate, as long as the voice
-    // signal matches
-    let expected_output =
-        recording_of_voice(output_pipeline.channels(), output_pipeline.sample_rate());
-    rodio::wav_to_file(output_pipeline.clone(), "output_pipeline_output.wav").unwrap();
-    rodio::wav_to_file(expected_output.clone(), "output_pipeline_expect.wav").unwrap();
-    assert_similar_voice_spectra(expected_output, output_pipeline);
-}
-
-// TODO make a perf variant
-#[gpui::test]
-fn test_full_audio_pipeline(cx: &mut gpui::TestAppContext) {
-    let test_signal = recording_of_voice(nz!(3), nz!(44_100));
-    let test_signal_duration = test_signal
-        .total_duration()
-        .expect("recordings have a length");
-
-    let audio_output =
-        cx.update(|cx| cx.update_default_global::<Audio, _>(|audio, _| audio.setup_mixer()));
-    let voip_parts = VoipParts::new(&cx.to_async()).unwrap();
-
-    let input = Audio::input_pipeline(voip_parts, test_signal).unwrap();
-    cx.update(|cx| Audio::play_voip_stream(input, "test".to_string(), true, cx).unwrap());
-
-    let full_pipeline = audio_output
-        .take_duration(test_signal_duration)
-        .into_samples_buffer();
-
-    // dont care about the channel count and sample rate, as long as the voice
-    // signal matches
-    let expected_output = recording_of_voice(full_pipeline.channels(), full_pipeline.sample_rate());
-    rodio::wav_to_file(full_pipeline.clone(), "full_pipeline_output.wav").unwrap();
-    rodio::wav_to_file(expected_output.clone(), "full_pipeline_expect.wav").unwrap();
-    assert_similar_voice_spectra(expected_output, full_pipeline);
-}
-
-fn human_perceivable_energy(spectrum: &FrequencySpectrum) -> f32 {
-    spectrum
-        .data()
-        .iter()
-        .filter(|(freq, _)| HUMAN_SPEECH_RANGE.contains(&freq.val()))
-        .max_by_key(|(_, energy)| energy)
-        .unwrap()
-        .1
-        .val()
-}
-
-fn energy_of_chunk(chunk: &[rodio::Sample], sample_rate: SampleRate) -> f32 {
-    let spectrum = samples_fft_to_spectrum(
-        &hann_window(chunk),
-        sample_rate.get(),
-        FrequencyLimit::All,
-        Some(&divide_by_N_sqrt),
-    )
-    .unwrap();
-
-    human_perceivable_energy(&spectrum)
-}
-
-fn maximum_energy(mut a: impl rodio::Source) -> f32 {
-    let a_samples: Vec<_> = a.by_ref().collect();
-    assert!(!a_samples.is_empty());
-    let ten_millis: usize = usize::try_from(a.sample_rate().get() / 100)
-        .unwrap()
-        .next_power_of_two();
-    a_samples
-        .chunks_exact(ten_millis)
-        .map(|chunk| energy_of_chunk(chunk, a.sample_rate()))
-        .fold(0f32, |max, energy| max.max(energy))
-}
-
-// Test signals should be at least 50% voice
-fn assert_similar_voice_spectra(
-    expected: impl rodio::Source + Clone,
-    pipeline: impl rodio::Source + Clone,
-) {
-    assert!(expected.total_duration().is_some());
-    assert!(pipeline.total_duration().is_some());
-
-    assert_eq!(expected.sample_rate(), pipeline.sample_rate());
-    assert_eq!(expected.channels(), pipeline.channels());
-
-    let total_duration = expected.total_duration().expect("just asserted");
-    let voice_detector = BasicVoiceDetector::new(expected.clone());
-    assert!(
-        voice_detector
-            .voice_less_duration()
-            .div_duration_f32(total_duration)
-            < 0.75,
-        "Test samples should be at least 25% voice and those parts should be recognized as such"
-    );
-
-    let sample_rate = expected.sample_rate();
-    let expected_samples: Vec<_> = expected.clone().collect();
-    let pipeline_samples: Vec<_> = pipeline.clone().collect();
-
-    const WINDOW_SIZE: usize = 2048;
-    const WINDOW_OVERLAP: usize = 0;
-
-    // beautiful functional code :3
-    let (passing, len) = voice_detector
-        .segments_with_voice
-        .into_iter()
-        .filter(|to_judge| to_judge.start_samples(sample_rate) > WINDOW_OVERLAP)
-        .filter(|to_judge| {
-            to_judge.end_samples(sample_rate) < expected_samples.len() - WINDOW_OVERLAP
-        })
-        .flat_map(|to_judge| {
-            let chunks = (to_judge.len_samples(sample_rate) + WINDOW_OVERLAP) / WINDOW_SIZE;
-            (0..chunks)
-                .map(|i| {
-                    let window_start =
-                        &to_judge.start_samples(sample_rate) + i * WINDOW_SIZE + WINDOW_OVERLAP;
-                    let window_center = window_start + WINDOW_SIZE / 2;
-                    let window_center = window_center as f64 / sample_rate.get() as f64;
-                    let window_center = Duration::from_secs_f64(window_center);
-                    (window_start, window_center)
-                })
-                .collect::<Vec<_>>()
-        })
-        .map(|(window_start, window_center)| {
-            let window = window_start..window_start + WINDOW_SIZE;
-            (
-                &expected_samples[window.clone()],
-                &pipeline_samples[dbg!(window)],
-                dbg!(window_center),
-            )
-        })
-        .map(|(input, output, window_center)| {
-            (
-                samples_fft_to_spectrum(
-                    &windows::hamming_window(input),
-                    sample_rate.get(),
-                    FrequencyLimit::Min(4.0),
-                    Some(&divide_by_N_sqrt),
-                )
-                .unwrap(),
-                samples_fft_to_spectrum(
-                    &windows::hamming_window(output),
-                    sample_rate.get(),
-                    FrequencyLimit::Min(4.0),
-                    Some(&divide_by_N_sqrt),
-                )
-                .unwrap(),
-                window_center,
-            )
-        })
-        .filter_map(assert_same_voice_signal)
-        .fold((0, 0), |(passing, len), passed| {
-            (passing + u32::from(passed), len + 1)
-        });
-
-    assert!(
-        passing > len * 9 / 10,
-        ">10% of chunks mismatched: {passing} passing out of {len}"
-    );
-}
-
-fn spectra_chunk_size(source: &impl Source, minimum_duration: Duration) -> usize {
-    ((minimum_duration.as_secs_f64() * source.sample_rate().get() as f64) as usize)
-        .next_power_of_two()
-}
-
-fn spectrum_duration(source: &impl Source, minimum_duration: Duration) -> Duration {
-    Duration::from_secs_f64(
-        spectra_chunk_size(source, minimum_duration) as f64 / source.sample_rate().get() as f64,
-    )
-}
-
-fn assert_same_voice_signal(
-    (expected, pipeline, window_center): (FrequencySpectrum, FrequencySpectrum, Duration),
-) -> Option<bool> {
-    // The timbre of a voice (the difference in how voices sound) is determined
-    // by all kinds of resonances in the throat/mouth. These happen roughly at
-    // multiples of the lowest usually loudest voice frequency.
-
-    let (voice_freq_expected, voice_freq_pipeline) = match (
-        fundamental_voice_freq(&expected),
-        fundamental_voice_freq(&pipeline),
-    ) {
-        (None, _) => return dbg!(None),
-        (Some(voice_freq_expected), None) => {
-            panic!(
-                "Could not find fundamental voice freq in output while there is one in the input at {voice_freq_expected}Hz.\nLoudest 5 frequencies in output:\n{}\n\n{}",
-                display_loudest_5_frequencies(&pipeline),
-                plot_spectra(&[(&expected, "expected"), (&pipeline, "pipeline")]),
-            );
-        }
-        (Some(voice_freq_expected), Some(voice_freq_pipeline)) => {
-            (voice_freq_expected, voice_freq_pipeline)
-        }
-    };
-
-    assert!(
-        less_than_10percent_diff((voice_freq_expected, voice_freq_pipeline)),
-        "expected: {voice_freq_expected}, pipeline: {voice_freq_pipeline}, at: {window_center:?}\n\n{}",
-        plot_spectra(&[(&expected, "expected"), (&pipeline, "pipeline")])
-    );
-
-    // Guards against voice distortion
-    // unfortunately affected by (de)noise as that (de)distorts voice.
-    Some(same_ratio_between_harmonics(
-        &expected,
-        &pipeline,
-        voice_freq_expected,
-    ))
-}
-
-fn fundamental_voice_freq(spectrum: &FrequencySpectrum) -> Option<f32> {
-    spectrum
-        .data()
-        .iter()
-        .filter(|(freq, _)| HUMAN_SPEECH_RANGE.contains(&freq.val()))
-        .max_by_key(|(_, energy)| energy)
-        .map(|(freq, _)| freq.val())
-}
-
-fn same_ratio_between_harmonics(
-    expected: &FrequencySpectrum,
-    pipeline: &FrequencySpectrum,
-    fundamental_voice_freq: f32,
-) -> bool {
-    fn ratios(
-        spectrum: &FrequencySpectrum,
-        fundamental_voice_freq: f32,
-    ) -> impl Iterator<Item = f32> {
-        let (_freq, fundamental) = spectrum.freq_val_closest(fundamental_voice_freq);
-
-        let voice_harmonics = (2..=3)
-            .into_iter()
-            .map(move |i| dbg!(fundamental_voice_freq) * i as f32);
-        voice_harmonics.clone().map(move |freq| {
-            let (_freq, harmonic) = spectrum.freq_val_closest(freq);
-            harmonic.val() / fundamental.val()
-        })
-    }
-
-    ratios(expected, fundamental_voice_freq)
-        .zip(ratios(pipeline, fundamental_voice_freq))
-        .all(less_than_20percent_diff)
-}
-
-fn less_than_10percent_diff((a, b): (f32, f32)) -> bool {
-    dbg!(a, b);
-    (a - b).abs() < a.max(b) * 0.1
-}
-
-fn less_than_20percent_diff((a, b): (f32, f32)) -> bool {
-    dbg!(a, b);
-    (a - b).abs() < a.max(b) * 0.3
-}
-
-fn display_loudest_5_frequencies(spectrum: &FrequencySpectrum) -> String {
-    let mut spectrum: Vec<_> = spectrum.data().iter().collect();
-    spectrum.sort_by_key(|(_, amplitude)| amplitude);
-    spectrum.reverse();
-    spectrum.truncate(5);
-    spectrum
-        .into_iter()
-        .map(|(freq, amplitude)| format!("freq: {freq},\tamplitude: {amplitude}\n"))
-        .collect()
-}
-
-// Returns ascii encoding a link to open the plot
-pub fn plot_spectra(spectra: &[(&FrequencySpectrum, &str)]) -> String {
-    use plotly::{Bar, Plot};
-
-    let mut plot = Plot::new();
-
-    let layout = plotly::Layout::new().x_axis(Axis::new().type_(plotly::layout::AxisType::Log));
-    // .y_axis(Axis::new().type_(plotly::layout::AxisType::Log));
-    plot.set_layout(layout);
-
-    for (spectrum, label) in spectra {
-        let (x, y): (Vec<_>, Vec<_>) = spectrum
-            .data()
-            .iter()
-            .map(|(freq, amplitude)| (freq.val(), amplitude.val()))
-            .filter(|(freq, _)| *freq > 85.0)
-            .unzip();
-        let trace = Bar::new(x, y).name(label).show_legend(true).opacity(0.5);
-        plot.add_trace(trace);
-    }
-
-    let path = current_dir().unwrap().join("plot.html");
-    plot.write_html(&path);
-
-    link(path.display(), "Open spectra plot")
-}
-
-fn link(target: impl std::fmt::Display, name: &str) -> String {
-    const START_OF_LINK: &str = "\x1b]8;;file://";
-    const START_OF_NAME: &str = "\x1b\\";
-    const END_OF_LINK: &str = "\x1b]8;;\x1b\\";
-
-    format!("{START_OF_LINK}{target}{START_OF_NAME}{name}{END_OF_LINK}")
-}
-
-pub(crate) fn sine(channels: ChannelCount, sample_rate: SampleRate) -> impl Source + Clone {
-    // We can not resample this file ourselves as then we would not be testing
-    // the resampler. These are test files resampled by audacity.
-    let recording = match (channels.get(), sample_rate.get()) {
-        (1, 48_000) => include_bytes!("../test/sine_1_48000.wav").as_slice(),
-        (2, 48_000) => include_bytes!("../test/sine_2_48000.wav").as_slice(),
-        _ => panic!("No test recording with {channels} channels and sampler rate: {sample_rate}"),
-    };
-
-    let recording = Cursor::new(recording);
-    let recording = Decoder::new(recording).unwrap();
-    SamplesBuffer::new(
-        recording.channels(),
-        recording.sample_rate(),
-        recording.collect::<Vec<_>>(),
-    )
-}
-
-pub(crate) fn recording_of_voice(
-    channels: ChannelCount,
-    sample_rate: SampleRate,
-) -> impl Source + Clone {
-    // We can not resample this file ourselves as then we would not be testing
-    // the resampler. These are test files resampled by audacity.
-    let recording = match (channels.get(), sample_rate.get()) {
-        (1, 44_100) => include_bytes!("../test/input_test_1_44100.wav").as_slice(),
-        (1, 48_000) => include_bytes!("../test/input_test_1_48000.wav").as_slice(),
-        (2, 44_100) => include_bytes!("../test/input_test_2_44100.wav").as_slice(),
-        (2, 48_000) => include_bytes!("../test/input_test_2_48000.wav").as_slice(),
-        (3, 44_100) => include_bytes!("../test/input_test_3_44100.wav").as_slice(),
-        (3, 48_000) => include_bytes!("../test/input_test_3_48000.wav").as_slice(),
-        _ => panic!("No test recording with {channels} channels and sampler rate: {sample_rate}"),
-    };
-
-    let recording = Cursor::new(recording);
-    let recording = Decoder::new(recording).unwrap();
-    SamplesBuffer::new(
-        recording.channels(),
-        recording.sample_rate(),
-        recording.collect::<Vec<_>>(),
-    )
-}
-
-#[test]
-#[should_panic]
-fn test_rejects_pitch_shift() {
-    // also known as 'robot/chipmunk voice'
-    let original = recording_of_voice(nz!(1), nz!(44100));
-    let pitch_shifted = original
-        .clone()
-        .speed(1.2) // effectively increases the pitch by 20%
-        .constant_samplerate(original.sample_rate())
-        .into_samples_buffer();
-    wav_to_file(original.clone(), "original.wav").unwrap();
-    wav_to_file(pitch_shifted.clone(), "pitch_shifted.wav").unwrap();
-
-    assert_similar_voice_spectra(original, pitch_shifted);
-}
-
-#[test]
-#[should_panic]
-fn test_rejects_large_amounts_of_noise() {
-    let original = recording_of_voice(nz!(1), nz!(44100));
-    let with_noise = add_noise(&original, 0.5);
-
-    assert_similar_voice_spectra(original, with_noise);
-}
-
-#[test]
-fn test_ignores_volume() {
-    let original = recording_of_voice(nz!(1), nz!(44100));
-    let amplified = original.clone().amplify(1.42);
-
-    assert_similar_voice_spectra(original, amplified);
-}
-
-#[test]
-fn test_ignore_low_volume_noise() {
-    let original = recording_of_voice(nz!(1), nz!(44100));
-    // 5% noise is quite hearable as the noise is across all frequencies so is
-    // perceived far more intense then a voice
-    let with_noise = add_noise(&original, 0.05);
-    assert_similar_voice_spectra(original, with_noise);
-}
-
-fn add_noise(original: &(impl Source + Clone + Send + 'static), amount: f32) -> SamplesBuffer {
-    let original_volume = original.clone().max_by(|a, b| a.total_cmp(b)).unwrap();
-
-    let noise = rodio::source::noise::WhiteUniform::new_with_rng(
-        original.sample_rate(),
-        SmallRng::seed_from_u64(1), // lets keep failure repeatable
-    );
-    let (mixer, with_noise) = mixer::mixer(original.channels(), original.sample_rate());
-
-    mixer.add(original.clone());
-    mixer.add(noise.amplify(amount * original_volume));
-
-    let with_noise = with_noise
-        .take_duration(
-            original
-                .total_duration()
-                .expect("should be a fixed length recording"),
-        )
-        .into_samples_buffer();
-    with_noise
-}
-
-#[test]
-fn test_ignores_small_shifts() {
-    let original = recording_of_voice(nz!(1), nz!(44100));
-    let shifted = iter::repeat(0f32).take(10).chain(original.clone());
-    let shifted = SamplesBuffer::new(
-        original.channels(),
-        original.sample_rate(),
-        shifted.collect::<Vec<_>>(),
-    );
-
-    assert_similar_voice_spectra(original, shifted);
-}
--- a/crates/audio/src/test/detector.rs
+++ b/crates/audio/src/test/detector.rs
@@ -1,210 +0,0 @@
-use crate::RodioExt;
-use crate::rodio_ext::ConstantChannelCount;
-use crate::test::sine;
-use crate::test::spectrum_duration;
-
-use super::human_perceivable_energy;
-
-use rodio::SampleRate;
-use rodio::buffer::SamplesBuffer;
-use rodio::nz;
-use spectrum_analyzer::FrequencyLimit;
-use spectrum_analyzer::FrequencySpectrum;
-use spectrum_analyzer::scaling::divide_by_N_sqrt;
-use spectrum_analyzer::windows::hann_window;
-
-use super::maximum_energy;
-
-use rodio::Source;
-
-use std::time::Duration;
-
-#[derive(Debug, Clone)]
-pub struct VoiceSegment {
-    pub start: Duration,
-    pub end: Duration,
-}
-
-impl VoiceSegment {
-    const ZERO: Self = Self {
-        start: Duration::ZERO,
-        end: Duration::ZERO,
-    };
-
-    fn length(&self) -> Duration {
-        self.end - self.start
-    }
-
-    fn until(&self, other: &Self) -> Duration {
-        debug_assert!(self.end < other.start);
-        other.start - self.end
-    }
-
-    pub(crate) fn len_samples(&self, sample_rate: SampleRate) -> usize {
-        (self.length().as_secs_f64() * sample_rate.get() as f64) as usize
-    }
-
-    pub(crate) fn start_samples(&self, sample_rate: SampleRate) -> usize {
-        (self.start.as_secs_f64() * sample_rate.get() as f64) as usize
-    }
-
-    pub(crate) fn end_samples(&self, sample_rate: SampleRate) -> usize {
-        (self.end.as_secs_f64() * sample_rate.get() as f64) as usize
-    }
-}
-
-pub(crate) struct BasicVoiceDetector {
-    pub(crate) segments_with_voice: Vec<VoiceSegment>,
-}
-
-impl BasicVoiceDetector {
-    pub(crate) fn new(source: impl Source + Clone) -> Self {
-        // only works on mono
-        let source = ConstantChannelCount::new(source, nz!(1)).into_samples_buffer();
-
-        // this gives a good resolution
-        let minimum_chunk_duration = Duration::from_millis(20);
-        let actual_chunk_duration = spectrum_duration(&source, minimum_chunk_duration);
-
-        let mut spectrum_start_pos = Duration::ZERO;
-        let mut partial_segment = None;
-
-        // empirically determined (by looking in audacity)
-        // see the 'soup' test for how
-        //
-        // while this might seem low remember humans precieve sound
-        // logarithmically. So 40% of energy sounds like 80% volume.
-        let threshold = 0.4 * maximum_energy(source.clone());
-        let segments_with_voice: Vec<_> = iter_spectra(source.clone(), actual_chunk_duration)
-            .filter_map(|spectrum| {
-                let voice_detected = human_perceivable_energy(&spectrum) > threshold;
-                spectrum_start_pos += actual_chunk_duration;
-                match (&mut partial_segment, voice_detected) {
-                    (Some(VoiceSegment { end, .. }), true) => *end = spectrum_start_pos,
-                    (Some(VoiceSegment { start, .. }), false) => {
-                        let res = Some(VoiceSegment {
-                            start: *start,
-                            end: spectrum_start_pos,
-                        });
-                        partial_segment = None;
-                        return res;
-                    }
-                    (None, true) => {
-                        partial_segment = Some(VoiceSegment {
-                            start: spectrum_start_pos,
-                            end: spectrum_start_pos,
-                        })
-                    }
-                    (None, false) => partial_segment = None,
-                };
-                None
-            })
-            .collect();
-
-        Self {
-            segments_with_voice,
-        }
-    }
-
-    pub fn voice_less_duration(&self) -> Duration {
-        self.segments_with_voice
-            .iter()
-            .map(|range| range.end - range.start)
-            .sum()
-    }
-
-    fn beep_where_voice_detected(&self, source: &impl Source) -> SamplesBuffer {
-        let sine = sine(nz!(1), source.sample_rate());
-
-        let mut with_voice = [VoiceSegment::ZERO]
-            .iter()
-            .chain(dbg!(&self.segments_with_voice).iter())
-            .peekable();
-        let mut samples = Vec::new();
-
-        loop {
-            let Some(current_voice_segment) = with_voice.next() else {
-                break;
-            };
-
-            let voice_range_duration = current_voice_segment.length();
-            samples.extend(
-                sine.clone()
-                    .amplify(1.0)
-                    .take_duration(voice_range_duration),
-            );
-
-            let Some(next_voice_segment) = with_voice.peek() else {
-                break;
-            };
-            let until_next = current_voice_segment.until(next_voice_segment);
-            dbg!(until_next);
-            samples.extend(sine.clone().amplify(0.0).take_duration(until_next));
-        }
-
-        SamplesBuffer::new(nz!(1), source.sample_rate(), samples)
-    }
-
-    pub fn add_voice_activity_as_channel(mut source: impl Source + Clone) -> impl Source {
-        let detector = Self::new(source.clone());
-        let mut voice_activity = detector.beep_where_voice_detected(&source).into_iter();
-
-        let mut samples = Vec::new();
-        loop {
-            let Some(s1) = source.next() else {
-                break;
-            };
-            let Some(s2) = source.next() else {
-                break;
-            };
-            let Some(s3) = voice_activity.next() else {
-                break;
-            };
-
-            samples.extend_from_slice(&[s1, s2, s3]);
-        }
-        SamplesBuffer::new(
-            source.channels().checked_add(1).unwrap(),
-            source.sample_rate(),
-            samples,
-        )
-    }
-}
-
-fn iter_spectra(
-    expected: impl Source + Clone,
-    chunk_duration: Duration,
-) -> impl Iterator<Item = FrequencySpectrum> {
-    assert!(expected.total_duration().is_some());
-
-    let chunk_size = super::spectra_chunk_size(&expected, chunk_duration);
-    let expected_samples: Vec<_> = expected.clone().collect();
-    expected_samples
-        .chunks_exact(chunk_size)
-        .map(|input| {
-            super::samples_fft_to_spectrum(
-                &hann_window(input),
-                expected.sample_rate().get(),
-                FrequencyLimit::Min(4.0),
-                Some(&divide_by_N_sqrt),
-            )
-            .unwrap()
-        })
-        .collect::<Vec<_>>()
-        .into_iter()
-}
-
-#[cfg(test)]
-mod test {
-
-    use crate::test::{detector::BasicVoiceDetector, recording_of_voice};
-    use rodio::{nz, wav_to_file};
-
-    #[test]
-    fn soup() {
-        let original = recording_of_voice(nz!(1), nz!(48000));
-        let detector = BasicVoiceDetector::new(original.clone());
-        let siny = detector.beep_where_voice_detected(&original);
-        wav_to_file(siny, "voice_activity.wav").unwrap();
-    }
-}
--- a/crates/audio/test/input_test_1_44100.wav
+++ b/crates/audio/test/input_test_1_44100.wav
--- a/crates/audio/test/input_test_1_48000.wav
+++ b/crates/audio/test/input_test_1_48000.wav
--- a/crates/audio/test/input_test_2_44100.wav
+++ b/crates/audio/test/input_test_2_44100.wav
--- a/crates/audio/test/input_test_2_48000.wav
+++ b/crates/audio/test/input_test_2_48000.wav
--- a/crates/audio/test/input_test_3_44100.wav
+++ b/crates/audio/test/input_test_3_44100.wav
--- a/crates/audio/test/input_test_3_48000.wav
+++ b/crates/audio/test/input_test_3_48000.wav
--- a/crates/audio/test/sine_1_48000.wav
+++ b/crates/audio/test/sine_1_48000.wav
--- a/crates/audio/test/sine_2_48000.wav
+++ b/crates/audio/test/sine_2_48000.wav
--- a/crates/auto_update/src/auto_update.rs
+++ b/crates/auto_update/src/auto_update.rs
@@ -127,7 +127,7 @@ struct AutoUpdateSetting(bool);
 ///
 /// Default: true
 impl Settings for AutoUpdateSetting {
-    fn from_settings(content: &settings::SettingsContent, _cx: &mut App) -> Self {
+    fn from_settings(content: &settings::SettingsContent) -> Self {
        Self(content.auto_update.unwrap())
    }
 }
--- a/crates/auto_update_helper/src/updater.rs
+++ b/crates/auto_update_helper/src/updater.rs
@@ -1,5 +1,4 @@
 use std::{
-    os::windows::process::CommandExt,
    path::Path,
    time::{Duration, Instant},
 };
@@ -7,7 +6,6 @@ use std::{
 use anyhow::{Context as _, Result};
 use windows::Win32::{
    Foundation::{HWND, LPARAM, WPARAM},
-    System::Threading::CREATE_NEW_PROCESS_GROUP,
    UI::WindowsAndMessaging::PostMessageW,
 };

@@ -38,6 +36,20 @@ pub(crate) const JOBS: &[Job] = &[
        std::fs::remove_file(&zed_wsl)
            .context(format!("Failed to remove old file {}", zed_wsl.display()))
    },
+    |app_dir| {
+        let open_console = app_dir.join("OpenConsole.exe");
+        log::info!("Removing old file: {}", open_console.display());
+        std::fs::remove_file(&open_console).context(format!(
+            "Failed to remove old file {}",
+            open_console.display()
+        ))
+    },
+    |app_dir| {
+        let conpty = app_dir.join("conpty.dll");
+        log::info!("Removing old file: {}", conpty.display());
+        std::fs::remove_file(&conpty)
+            .context(format!("Failed to remove old file {}", conpty.display()))
+    },
    // Copy new files
    |app_dir| {
        let zed_executable_source = app_dir.join("install\\Zed.exe");
@@ -87,6 +99,38 @@ pub(crate) const JOBS: &[Job] = &[
                zed_wsl_dest.display()
            ))
    },
+    |app_dir| {
+        let open_console_source = app_dir.join("install\\OpenConsole.exe");
+        let open_console_dest = app_dir.join("OpenConsole.exe");
+        log::info!(
+            "Copying new file {} to {}",
+            open_console_source.display(),
+            open_console_dest.display()
+        );
+        std::fs::copy(&open_console_source, &open_console_dest)
+            .map(|_| ())
+            .context(format!(
+                "Failed to copy new file {} to {}",
+                open_console_source.display(),
+                open_console_dest.display()
+            ))
+    },
+    |app_dir| {
+        let conpty_source = app_dir.join("install\\conpty.dll");
+        let conpty_dest = app_dir.join("conpty.dll");
+        log::info!(
+            "Copying new file {} to {}",
+            conpty_source.display(),
+            conpty_dest.display()
+        );
+        std::fs::copy(&conpty_source, &conpty_dest)
+            .map(|_| ())
+            .context(format!(
+                "Failed to copy new file {} to {}",
+                conpty_source.display(),
+                conpty_dest.display()
+            ))
+    },
    // Clean up installer folder and updates folder
    |app_dir| {
        let updates_folder = app_dir.join("updates");
@@ -161,9 +205,7 @@ pub(crate) fn perform_update(app_dir: &Path, hwnd: Option<isize>, launch: bool)
    }
    if launch {
        #[allow(clippy::disallowed_methods, reason = "doesn't run in the main binary")]
-        let _ = std::process::Command::new(app_dir.join("Zed.exe"))
-            .creation_flags(CREATE_NEW_PROCESS_GROUP.0)
-            .spawn();
+        let _ = std::process::Command::new(app_dir.join("Zed.exe")).spawn();
    }
    log::info!("Update completed successfully");
    Ok(())
--- a/crates/bedrock/src/models.rs
+++ b/crates/bedrock/src/models.rs
@@ -22,7 +22,6 @@ pub struct BedrockModelCacheConfiguration {
 #[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, EnumIter)]
 pub enum Model {
    // Anthropic models (already included)
-    #[default]
    #[serde(rename = "claude-sonnet-4", alias = "claude-sonnet-4-latest")]
    ClaudeSonnet4,
    #[serde(
@@ -30,6 +29,14 @@ pub enum Model {
        alias = "claude-sonnet-4-thinking-latest"
    )]
    ClaudeSonnet4Thinking,
+    #[default]
+    #[serde(rename = "claude-sonnet-4-5", alias = "claude-sonnet-4-5-latest")]
+    ClaudeSonnet4_5,
+    #[serde(
+        rename = "claude-sonnet-4-5-thinking",
+        alias = "claude-sonnet-4-5-thinking-latest"
+    )]
+    ClaudeSonnet4_5Thinking,
    #[serde(rename = "claude-opus-4", alias = "claude-opus-4-latest")]
    ClaudeOpus4,
    #[serde(rename = "claude-opus-4-1", alias = "claude-opus-4-1-latest")]
@@ -144,6 +151,14 @@ impl Model {
            Ok(Self::Claude3_7Sonnet)
        } else if id.starts_with("claude-3-7-sonnet-thinking") {
            Ok(Self::Claude3_7SonnetThinking)
+        } else if id.starts_with("claude-sonnet-4-5-thinking") {
+            Ok(Self::ClaudeSonnet4_5Thinking)
+        } else if id.starts_with("claude-sonnet-4-5") {
+            Ok(Self::ClaudeSonnet4_5)
+        } else if id.starts_with("claude-sonnet-4-thinking") {
+            Ok(Self::ClaudeSonnet4Thinking)
+        } else if id.starts_with("claude-sonnet-4") {
+            Ok(Self::ClaudeSonnet4)
        } else {
            anyhow::bail!("invalid model id {id}");
        }
@@ -153,6 +168,8 @@ impl Model {
        match self {
            Model::ClaudeSonnet4 => "claude-sonnet-4",
            Model::ClaudeSonnet4Thinking => "claude-sonnet-4-thinking",
+            Model::ClaudeSonnet4_5 => "claude-sonnet-4-5",
+            Model::ClaudeSonnet4_5Thinking => "claude-sonnet-4-5-thinking",
            Model::ClaudeOpus4 => "claude-opus-4",
            Model::ClaudeOpus4_1 => "claude-opus-4-1",
            Model::ClaudeOpus4Thinking => "claude-opus-4-thinking",
@@ -214,6 +231,9 @@ impl Model {
            Model::ClaudeSonnet4 | Model::ClaudeSonnet4Thinking => {
                "anthropic.claude-sonnet-4-20250514-v1:0"
            }
+            Model::ClaudeSonnet4_5 | Model::ClaudeSonnet4_5Thinking => {
+                "anthropic.claude-sonnet-4-5-20250929-v1:0"
+            }
            Model::ClaudeOpus4 | Model::ClaudeOpus4Thinking => {
                "anthropic.claude-opus-4-20250514-v1:0"
            }
@@ -277,6 +297,8 @@ impl Model {
        match self {
            Self::ClaudeSonnet4 => "Claude Sonnet 4",
            Self::ClaudeSonnet4Thinking => "Claude Sonnet 4 Thinking",
+            Self::ClaudeSonnet4_5 => "Claude Sonnet 4.5",
+            Self::ClaudeSonnet4_5Thinking => "Claude Sonnet 4.5 Thinking",
            Self::ClaudeOpus4 => "Claude Opus 4",
            Self::ClaudeOpus4_1 => "Claude Opus 4.1",
            Self::ClaudeOpus4Thinking => "Claude Opus 4 Thinking",
@@ -346,6 +368,8 @@ impl Model {
            | Self::ClaudeOpus4
            | Self::ClaudeOpus4_1
            | Self::ClaudeSonnet4Thinking
+            | Self::ClaudeSonnet4_5
+            | Self::ClaudeSonnet4_5Thinking
            | Self::ClaudeOpus4Thinking
            | Self::ClaudeOpus4_1Thinking => 200_000,
            Self::AmazonNovaPremier => 1_000_000,
@@ -361,6 +385,7 @@ impl Model {
            Self::Claude3Opus | Self::Claude3Sonnet | Self::Claude3_5Haiku => 4_096,
            Self::Claude3_7Sonnet | Self::Claude3_7SonnetThinking => 128_000,
            Self::ClaudeSonnet4 | Self::ClaudeSonnet4Thinking => 64_000,
+            Self::ClaudeSonnet4_5 | Self::ClaudeSonnet4_5Thinking => 64_000,
            Self::ClaudeOpus4
            | Self::ClaudeOpus4Thinking
            | Self::ClaudeOpus4_1
@@ -385,7 +410,9 @@ impl Model {
            | Self::ClaudeOpus4_1
            | Self::ClaudeOpus4_1Thinking
            | Self::ClaudeSonnet4
-            | Self::ClaudeSonnet4Thinking => 1.0,
+            | Self::ClaudeSonnet4Thinking
+            | Self::ClaudeSonnet4_5
+            | Self::ClaudeSonnet4_5Thinking => 1.0,
            Self::Custom {
                default_temperature,
                ..
@@ -409,6 +436,8 @@ impl Model {
            | Self::ClaudeOpus4_1Thinking
            | Self::ClaudeSonnet4
            | Self::ClaudeSonnet4Thinking
+            | Self::ClaudeSonnet4_5
+            | Self::ClaudeSonnet4_5Thinking
            | Self::Claude3_5Haiku => true,

            // Amazon Nova models (all support tool use)
@@ -439,6 +468,8 @@ impl Model {
            | Self::Claude3_7SonnetThinking
            | Self::ClaudeSonnet4
            | Self::ClaudeSonnet4Thinking
+            | Self::ClaudeSonnet4_5
+            | Self::ClaudeSonnet4_5Thinking
            | Self::ClaudeOpus4
            | Self::ClaudeOpus4Thinking
            | Self::ClaudeOpus4_1
@@ -488,9 +519,11 @@ impl Model {
            Model::Claude3_7SonnetThinking => BedrockModelMode::Thinking {
                budget_tokens: Some(4096),
            },
-            Model::ClaudeSonnet4Thinking => BedrockModelMode::Thinking {
-                budget_tokens: Some(4096),
-            },
+            Model::ClaudeSonnet4Thinking | Model::ClaudeSonnet4_5Thinking => {
+                BedrockModelMode::Thinking {
+                    budget_tokens: Some(4096),
+                }
+            }
            Model::ClaudeOpus4Thinking | Model::ClaudeOpus4_1Thinking => {
                BedrockModelMode::Thinking {
                    budget_tokens: Some(4096),
@@ -542,6 +575,8 @@ impl Model {
                | Model::Claude3_7SonnetThinking
                | Model::ClaudeSonnet4
                | Model::ClaudeSonnet4Thinking
+                | Model::ClaudeSonnet4_5
+                | Model::ClaudeSonnet4_5Thinking
                | Model::ClaudeOpus4
                | Model::ClaudeOpus4Thinking
                | Model::ClaudeOpus4_1
@@ -575,6 +610,8 @@ impl Model {
                | Model::Claude3_7SonnetThinking
                | Model::ClaudeSonnet4
                | Model::ClaudeSonnet4Thinking
+                | Model::ClaudeSonnet4_5
+                | Model::ClaudeSonnet4_5Thinking
                | Model::Claude3Haiku
                | Model::Claude3Sonnet
                | Model::MetaLlama321BInstructV1
@@ -592,7 +629,9 @@ impl Model {
                | Model::Claude3_7Sonnet
                | Model::Claude3_7SonnetThinking
                | Model::ClaudeSonnet4
-                | Model::ClaudeSonnet4Thinking,
+                | Model::ClaudeSonnet4Thinking
+                | Model::ClaudeSonnet4_5
+                | Model::ClaudeSonnet4_5Thinking,
                "apac",
            ) => Ok(format!("{}.{}", region_group, model_id)),

@@ -631,6 +670,10 @@ mod tests {
            Model::ClaudeSonnet4.cross_region_inference_id("eu-west-1")?,
            "eu.anthropic.claude-sonnet-4-20250514-v1:0"
        );
+        assert_eq!(
+            Model::ClaudeSonnet4_5.cross_region_inference_id("eu-west-1")?,
+            "eu.anthropic.claude-sonnet-4-5-20250929-v1:0"
+        );
        assert_eq!(
            Model::Claude3Sonnet.cross_region_inference_id("eu-west-1")?,
            "eu.anthropic.claude-3-sonnet-20240229-v1:0"
--- a/crates/call/src/call_impl/room.rs
+++ b/crates/call/src/call_impl/room.rs
@@ -23,7 +23,7 @@ use livekit_client::{self as livekit, AudioStream, TrackSid};
 use postage::{sink::Sink, stream::Stream, watch};
 use project::Project;
 use settings::Settings as _;
-use std::{future::Future, mem, rc::Rc, sync::Arc, time::Duration};
+use std::{future::Future, mem, rc::Rc, sync::Arc, time::Duration, time::Instant};
 use util::{ResultExt, TryFutureExt, paths::PathStyle, post_inc};

 pub const RECONNECT_TIMEOUT: Duration = Duration::from_secs(30);
@@ -86,6 +86,7 @@ pub struct Room {
    room_update_completed_rx: watch::Receiver<Option<()>>,
    pending_room_update: Option<Task<()>>,
    maintain_connection: Option<Task<Option<()>>>,
+    created: Instant,
 }

 impl EventEmitter<Event> for Room {}
@@ -157,6 +158,7 @@ impl Room {
            maintain_connection: Some(maintain_connection),
            room_update_completed_tx,
            room_update_completed_rx,
+            created: cx.background_executor().now(),
        }
    }

@@ -827,7 +829,17 @@ impl Room {
                                },
                            );

-                            Audio::play_sound(Sound::Joined, cx);
+                            // When joining a room start_room_connection gets
+                            // called but we have already played the join sound.
+                            // Dont play extra sounds over that.
+                            if this.created.elapsed() > Duration::from_millis(100) {
+                                if let proto::ChannelRole::Guest = role {
+                                    Audio::play_sound(Sound::GuestJoined, cx);
+                                } else {
+                                    Audio::play_sound(Sound::Joined, cx);
+                                }
+                            }
+
                            if let Some(livekit_participants) = &livekit_participants
                                && let Some(livekit_participant) = livekit_participants
                                    .get(&ParticipantIdentity(user.id.to_string()))
--- a/crates/call/src/call_settings.rs
+++ b/crates/call/src/call_settings.rs
@@ -1,4 +1,3 @@
-use gpui::App;
 use settings::Settings;

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

 impl Settings for CallSettings {
-    fn from_settings(content: &settings::SettingsContent, _cx: &mut App) -> Self {
+    fn from_settings(content: &settings::SettingsContent) -> Self {
        let call = content.calls.clone().unwrap();
        CallSettings {
            mute_on_join: call.mute_on_join.unwrap(),
            share_on_join: call.share_on_join.unwrap(),
        }
    }
-
-    fn import_from_vscode(
-        _vscode: &settings::VsCodeSettings,
-        _current: &mut settings::SettingsContent,
-    ) {
-    }
 }
--- a/crates/cli/Cargo.toml
+++ b/crates/cli/Cargo.toml
@@ -22,6 +22,7 @@ default = []

 [dependencies]
 anyhow.workspace = true
+askpass.workspace = true
 clap.workspace = true
 collections.workspace = true
 ipc-channel = "0.19"
--- a/crates/cli/src/main.rs
+++ b/crates/cli/src/main.rs
@@ -116,6 +116,11 @@ struct Args {
    ))]
    #[arg(long)]
    uninstall: bool,
+
+    /// Used for SSH/Git password authentication, to remove the need for netcat as a dependency,
+    /// by having Zed act like netcat communicating over a Unix socket.
+    #[arg(long, hide = true)]
+    askpass: Option<String>,
 }

 fn parse_path_with_position(argument_str: &str) -> anyhow::Result<String> {
@@ -143,7 +148,7 @@ fn parse_path_with_position(argument_str: &str) -> anyhow::Result<String> {
        }
        .with_context(|| format!("parsing as path with position {argument_str}"))?,
    };
-    Ok(canonicalized.to_string(|path| path.to_string_lossy().to_string()))
+    Ok(canonicalized.to_string(|path| path.to_string_lossy().into_owned()))
 }

 fn parse_path_in_wsl(source: &str, wsl: &str) -> Result<String> {
@@ -203,6 +208,12 @@ fn main() -> Result<()> {
    }
    let args = Args::parse();

+    // `zed --askpass` Makes zed operate in nc/netcat mode for use with askpass
+    if let Some(socket) = &args.askpass {
+        askpass::main(socket);
+        return Ok(());
+    }
+
    // Set custom data directory before any path operations
    let user_data_dir = args.user_data_dir.clone();
    if let Some(dir) = &user_data_dir {
@@ -320,12 +331,12 @@ fn main() -> Result<()> {
            urls.push(path.to_string());
        } else if path == "-" && args.paths_with_position.len() == 1 {
            let file = NamedTempFile::new()?;
-            paths.push(file.path().to_string_lossy().to_string());
+            paths.push(file.path().to_string_lossy().into_owned());
            let (file, _) = file.keep()?;
            stdin_tmp_file = Some(file);
        } else if let Some(file) = anonymous_fd(path) {
            let tmp_file = NamedTempFile::new()?;
-            paths.push(tmp_file.path().to_string_lossy().to_string());
+            paths.push(tmp_file.path().to_string_lossy().into_owned());
            let (tmp_file, _) = tmp_file.keep()?;
            anonymous_fd_tmp_files.push((file, tmp_file));
        } else if let Some(wsl) = wsl {
@@ -720,15 +731,15 @@ mod windows {
            Storage::FileSystem::{
                CreateFileW, FILE_FLAGS_AND_ATTRIBUTES, FILE_SHARE_MODE, OPEN_EXISTING, WriteFile,
            },
-            System::Threading::{CREATE_NEW_PROCESS_GROUP, CreateMutexW},
+            System::Threading::CreateMutexW,
        },
        core::HSTRING,
    };

    use crate::{Detect, InstalledApp};
+    use std::io;
    use std::path::{Path, PathBuf};
    use std::process::ExitStatus;
-    use std::{io, os::windows::process::CommandExt};

    fn check_single_instance() -> bool {
        let mutex = unsafe {
@@ -767,7 +778,6 @@ mod windows {
        fn launch(&self, ipc_url: String) -> anyhow::Result<()> {
            if check_single_instance() {
                std::process::Command::new(self.0.clone())
-                    .creation_flags(CREATE_NEW_PROCESS_GROUP.0)
                    .arg(ipc_url)
                    .spawn()?;
            } else {
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -101,7 +101,7 @@ pub struct ClientSettings {
 }

 impl Settings for ClientSettings {
-    fn from_settings(content: &settings::SettingsContent, _cx: &mut App) -> Self {
+    fn from_settings(content: &settings::SettingsContent) -> Self {
        if let Some(server_url) = &*ZED_SERVER_URL {
            return Self {
                server_url: server_url.clone(),
@@ -133,7 +133,7 @@ impl ProxySettings {
 }

 impl Settings for ProxySettings {
-    fn from_settings(content: &settings::SettingsContent, _cx: &mut App) -> Self {
+    fn from_settings(content: &settings::SettingsContent) -> Self {
        Self {
            proxy: content.proxy.clone(),
        }
@@ -519,7 +519,7 @@ pub struct TelemetrySettings {
 }

 impl settings::Settings for TelemetrySettings {
-    fn from_settings(content: &SettingsContent, _cx: &mut App) -> Self {
+    fn from_settings(content: &SettingsContent) -> Self {
        Self {
            diagnostics: content.telemetry.as_ref().unwrap().diagnostics.unwrap(),
            metrics: content.telemetry.as_ref().unwrap().metrics.unwrap(),
--- a/crates/cloud_llm_client/src/predict_edits_v3.rs
+++ b/crates/cloud_llm_client/src/predict_edits_v3.rs
@@ -43,15 +43,24 @@ pub struct PredictEditsRequest {
    pub prompt_format: PromptFormat,
 }

-#[derive(Default, Debug, Clone, Copy, Serialize, Deserialize, PartialEq, EnumIter)]
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, EnumIter)]
 pub enum PromptFormat {
-    #[default]
    MarkedExcerpt,
    LabeledSections,
    /// Prompt format intended for use via zeta_cli
    OnlySnippets,
 }

+impl PromptFormat {
+    pub const DEFAULT: PromptFormat = PromptFormat::LabeledSections;
+}
+
+impl Default for PromptFormat {
+    fn default() -> Self {
+        Self::DEFAULT
+    }
+}
+
 impl PromptFormat {
    pub fn iter() -> impl Iterator<Item = Self> {
        <Self as strum::IntoEnumIterator>::iter()
@@ -118,7 +127,6 @@ pub struct DeclarationScoreComponents {
    pub declaration_count: usize,
    pub reference_line_distance: u32,
    pub declaration_line_distance: u32,
-    pub declaration_line_distance_rank: usize,
    pub excerpt_vs_item_jaccard: f32,
    pub excerpt_vs_signature_jaccard: f32,
    pub adjacent_vs_item_jaccard: f32,
@@ -127,6 +135,13 @@ pub struct DeclarationScoreComponents {
    pub excerpt_vs_signature_weighted_overlap: f32,
    pub adjacent_vs_item_weighted_overlap: f32,
    pub adjacent_vs_signature_weighted_overlap: f32,
+    pub path_import_match_count: usize,
+    pub wildcard_path_import_match_count: usize,
+    pub import_similarity: f32,
+    pub max_import_similarity: f32,
+    pub normalized_import_similarity: f32,
+    pub wildcard_import_similarity: f32,
+    pub normalized_wildcard_import_similarity: f32,
 }

 #[derive(Debug, Clone, Serialize, Deserialize)]
--- a/crates/cloud_zeta2_prompt/Cargo.toml
+++ b/crates/cloud_zeta2_prompt/Cargo.toml
@@ -17,5 +17,6 @@ cloud_llm_client.workspace = true
 indoc.workspace = true
 ordered-float.workspace = true
 rustc-hash.workspace = true
+serde.workspace = true
 strum.workspace = true
 workspace-hack.workspace = true
--- a/crates/cloud_zeta2_prompt/src/cloud_zeta2_prompt.rs
+++ b/crates/cloud_zeta2_prompt/src/cloud_zeta2_prompt.rs
@@ -5,6 +5,7 @@ use cloud_llm_client::predict_edits_v3::{self, Event, PromptFormat, ReferencedDe
 use indoc::indoc;
 use ordered_float::OrderedFloat;
 use rustc_hash::{FxHashMap, FxHashSet};
+use serde::Serialize;
 use std::fmt::Write;
 use std::sync::Arc;
 use std::{cmp::Reverse, collections::BinaryHeap, ops::Range, path::Path};
@@ -75,7 +76,7 @@ pub enum DeclarationStyle {
    Declaration,
 }

-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize)]
 pub struct SectionLabels {
    pub excerpt_index: usize,
    pub section_ranges: Vec<(Arc<Path>, Range<usize>)>,
--- a/crates/codestral/Cargo.toml
+++ b/crates/codestral/Cargo.toml
@@ -0,0 +1,28 @@
+[package]
+name = "codestral"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "GPL-3.0-or-later"
+
+[lib]
+path = "src/codestral.rs"
+
+[dependencies]
+anyhow.workspace = true
+edit_prediction.workspace = true
+edit_prediction_context.workspace = true
+futures.workspace = true
+gpui.workspace = true
+http_client.workspace = true
+language.workspace = true
+language_models.workspace = true
+log.workspace = true
+mistral.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+smol.workspace = true
+text.workspace = true
+workspace-hack.workspace = true
+
+[dev-dependencies]
--- a/Show More
+++ b/Show More