Write a rustdoc2md example binary to explore markdown generation

Add output offsets for items, CLI example to test
2024-06-24 16:08:58 -06:00 · 2024-06-24 15:53:20 -06:00
349 changed files with 6511 additions and 14921 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -254,7 +254,7 @@ jobs:
            target/aarch64-apple-darwin/release/Zed-aarch64.dmg
            target/x86_64-apple-darwin/release/Zed-x86_64.dmg
            target/release/Zed.dmg
-          body_path: target/release-notes.md
+          body_file: target/release-notes.md
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

@@ -402,7 +402,7 @@ jobs:

      - name: Upload app bundle to release
        uses: softprops/action-gh-release@v1
-        if: ${{ env.RELEASE_CHANNEL == 'preview' || env.RELEASE_CHANNEL == 'stable' }}
+        if: ${{ env.RELEASE_CHANNEL == 'preview' }}
        with:
          draft: true
          prerelease: ${{ env.RELEASE_CHANNEL == 'preview' }}
--- a/.mailmap
+++ b/.mailmap
@@ -7,12 +7,10 @@
 # Reference: https://git-scm.com/docs/gitmailmap

 # Keep these entries sorted alphabetically.
-# In Zed: `editor: sort lines case insensitive`
+# In Zed: `editor: sort lines case sensitive`

 Alex Viscreanu <alexviscreanu@gmail.com>
 Alex Viscreanu <alexviscreanu@gmail.com> <alexandru.viscreanu@kiwi.com>
-amtoaer <amtoaer@gmail.com>
-amtoaer <amtoaer@gmail.com> <amtoaer@outlook.com>
 Antonio Scandurra <me@as-cii.com>
 Antonio Scandurra <me@as-cii.com> <antonio@zed.dev>
 Bennet Bo Fenner <bennet@zed.dev>
@@ -22,8 +20,6 @@ Christian Bergschneider <christian.bergschneider@gmx.de>
 Christian Bergschneider <christian.bergschneider@gmx.de> <magiclake@gmx.de>
 Conrad Irwin <conrad@zed.dev>
 Conrad Irwin <conrad@zed.dev> <conrad.irwin@gmail.com>
-Danilo Leal <danilo@zed.dev>
-Danilo Leal <danilo@zed.dev> <67129314+danilo-leal@users.noreply.github.com>
 Evren Sen <146845123+evrsen@users.noreply.github.com>
 Fernando Tagawa <tagawafernando@gmail.com>
 Fernando Tagawa <tagawafernando@gmail.com> <fernando.tagawa.gamail.com@gmail.com>
@@ -58,16 +54,12 @@ Nate Butler <iamnbutler@gmail.com> <nate@zed.dev>
 Nathan Sobo <nathan@zed.dev>
 Nathan Sobo <nathan@zed.dev> <nathan@warp.dev>
 Nathan Sobo <nathan@zed.dev> <nathansobo@gmail.com>
-Nigel Jose <nigelmjose@gmail.com>
-Nigel Jose <nigelmjose@gmail.com> <nigel.jose@student.manchester.ac.uk>
 Peter Tripp <peter@zed.dev>
 Peter Tripp <peter@zed.dev> <petertripp@gmail.com>
 Petros Amoiridis <petros@hey.com>
 Petros Amoiridis <petros@hey.com> <petros@zed.dev>
 Piotr Osiewicz <piotr@zed.dev>
 Piotr Osiewicz <piotr@zed.dev> <24362066+osiewicz@users.noreply.github.com>
-Pocæus <github@pocaeus.com>
-Pocæus <github@pocaeus.com> <pseudomata@proton.me>
 Rashid Almheiri <r.muhairi@pm.me>
 Rashid Almheiri <r.muhairi@pm.me> <69181766+huwaireb@users.noreply.github.com>
 Richard Feldman <oss@rtfeldman.com>
--- a/.zed/settings.json
+++ b/.zed/settings.json
@@ -14,24 +14,11 @@
    },
    "JSON": {
      "tab_size": 2,
-      "preferred_line_length": 100,
-      "formatter": "prettier"
-    },
-    "JSONC": {
-      "tab_size": 2,
-      "preferred_line_length": 100,
      "formatter": "prettier"
    },
    "JavaScript": {
      "tab_size": 2,
      "formatter": "prettier"
-    },
-    "Rust": {
-      "tasks": {
-        "variables": {
-          "RUST_DEFAULT_PACKAGE_RUN": "zed"
-        }
-      }
    }
  },
  "formatter": "auto",
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -41,7 +41,7 @@ We plan to set aside time each week to pair program with contributors on promisi

 Zed is made up of several smaller crates - let's go over those you're most likely to interact with:

- [`gpui`](/crates/gpui) is a GPU-accelerated UI framework which provides all of the building blocks for Zed. **We recommend familiarizing yourself with the root level GPUI documentation.**
+- [`gpui`](/crates/gpui) is a GPU-accelerated UI framework which provides all of the building blocks for Zed. **We recommend familiarizing yourself with the root level GPUI documentation**
 - [`editor`](/crates/editor) contains the core `Editor` type that drives both the code editor and all various input fields within Zed. It also handles a display layer for LSP features such as Inlay Hints or code completions.
 - [`project`](/crates/project) manages files and navigation within the filetree. It is also Zed's side of communication with LSP.
 - [`workspace`](/crates/workspace) handles local state serialization and groups projects together.
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -21,7 +21,6 @@ members = [
    "crates/command_palette_hooks",
    "crates/copilot",
    "crates/db",
-    "crates/dev_server_projects",
    "crates/diagnostics",
    "crates/editor",
    "crates/extension",
@@ -45,7 +44,6 @@ members = [
    "crates/html_to_markdown",
    "crates/http",
    "crates/image_viewer",
-    "crates/indexed_docs",
    "crates/inline_completion_button",
    "crates/install_cli",
    "crates/journal",
@@ -79,10 +77,14 @@ members = [
    "crates/refineable",
    "crates/refineable/derive_refineable",
    "crates/release_channel",
+    "crates/dev_server_projects",
    "crates/repl",
    "crates/rich_text",
    "crates/rope",
    "crates/rpc",
+    "crates/rustdoc",
+    "crates/task",
+    "crates/tasks_ui",
    "crates/search",
    "crates/semantic_index",
    "crates/semantic_version",
@@ -93,20 +95,17 @@ members = [
    "crates/story",
    "crates/storybook",
    "crates/sum_tree",
+    "crates/tab_switcher",
    "crates/supermaven",
    "crates/supermaven_api",
-    "crates/tab_switcher",
-    "crates/task",
-    "crates/tasks_ui",
-    "crates/telemetry_events",
    "crates/terminal",
    "crates/terminal_view",
    "crates/text",
    "crates/theme",
    "crates/theme_importer",
    "crates/theme_selector",
+    "crates/telemetry_events",
    "crates/time_format",
-    "crates/title_bar",
    "crates/ui",
    "crates/ui_text_field",
    "crates/util",
@@ -140,7 +139,6 @@ members = [
    "extensions/snippets",
    "extensions/svelte",
    "extensions/terraform",
-    "extensions/test-extension",
    "extensions/toml",
    "extensions/uiua",
    "extensions/vue",
@@ -159,8 +157,10 @@ assets = { path = "crates/assets" }
 assistant = { path = "crates/assistant" }
 assistant_slash_command = { path = "crates/assistant_slash_command" }
 assistant_tooling = { path = "crates/assistant_tooling" }
+async-watch = "0.3.1"
 audio = { path = "crates/audio" }
 auto_update = { path = "crates/auto_update" }
+base64 = "0.13"
 breadcrumbs = { path = "crates/breadcrumbs" }
 call = { path = "crates/call" }
 channel = { path = "crates/channel" }
@@ -173,8 +173,8 @@ collections = { path = "crates/collections" }
 command_palette = { path = "crates/command_palette" }
 command_palette_hooks = { path = "crates/command_palette_hooks" }
 copilot = { path = "crates/copilot" }
+dashmap = "5.5.3"
 db = { path = "crates/db" }
-dev_server_projects = { path = "crates/dev_server_projects" }
 diagnostics = { path = "crates/diagnostics" }
 editor = { path = "crates/editor" }
 extension = { path = "crates/extension" }
@@ -195,10 +195,9 @@ gpui_macros = { path = "crates/gpui_macros" }
 headless = { path = "crates/headless" }
 html_to_markdown = { path = "crates/html_to_markdown" }
 http = { path = "crates/http" }
-image_viewer = { path = "crates/image_viewer" }
-indexed_docs = { path = "crates/indexed_docs" }
-inline_completion_button = { path = "crates/inline_completion_button" }
 install_cli = { path = "crates/install_cli" }
+image_viewer = { path = "crates/image_viewer" }
+inline_completion_button = { path = "crates/inline_completion_button" }
 journal = { path = "crates/journal" }
 language = { path = "crates/language" }
 language_selector = { path = "crates/language_selector" }
@@ -224,16 +223,21 @@ plugin = { path = "crates/plugin" }
 plugin_macros = { path = "crates/plugin_macros" }
 prettier = { path = "crates/prettier" }
 project = { path = "crates/project" }
+proto = { path = "crates/proto" }
+worktree = { path = "crates/worktree" }
 project_panel = { path = "crates/project_panel" }
 project_symbols = { path = "crates/project_symbols" }
-proto = { path = "crates/proto" }
 quick_action_bar = { path = "crates/quick_action_bar" }
 recent_projects = { path = "crates/recent_projects" }
 release_channel = { path = "crates/release_channel" }
+dev_server_projects = { path = "crates/dev_server_projects" }
 repl = { path = "crates/repl" }
 rich_text = { path = "crates/rich_text" }
 rope = { path = "crates/rope" }
 rpc = { path = "crates/rpc" }
+rustdoc = { path = "crates/rustdoc" }
+task = { path = "crates/task" }
+tasks_ui = { path = "crates/tasks_ui" }
 search = { path = "crates/search" }
 semantic_index = { path = "crates/semantic_index" }
 semantic_version = { path = "crates/semantic_version" }
@@ -241,23 +245,20 @@ settings = { path = "crates/settings" }
 snippet = { path = "crates/snippet" }
 sqlez = { path = "crates/sqlez" }
 sqlez_macros = { path = "crates/sqlez_macros" }
+supermaven = { path = "crates/supermaven" }
+supermaven_api = { path = "crates/supermaven_api" }
 story = { path = "crates/story" }
 storybook = { path = "crates/storybook" }
 sum_tree = { path = "crates/sum_tree" }
-supermaven = { path = "crates/supermaven" }
-supermaven_api = { path = "crates/supermaven_api" }
 tab_switcher = { path = "crates/tab_switcher" }
-task = { path = "crates/task" }
-tasks_ui = { path = "crates/tasks_ui" }
-telemetry_events = { path = "crates/telemetry_events" }
 terminal = { path = "crates/terminal" }
 terminal_view = { path = "crates/terminal_view" }
 text = { path = "crates/text" }
 theme = { path = "crates/theme" }
 theme_importer = { path = "crates/theme_importer" }
 theme_selector = { path = "crates/theme_selector" }
+telemetry_events = { path = "crates/telemetry_events" }
 time_format = { path = "crates/time_format" }
-title_bar = { path = "crates/title_bar" }
 ui = { path = "crates/ui" }
 ui_text_field = { path = "crates/ui_text_field" }
 util = { path = "crates/util" }
@@ -265,13 +266,12 @@ vcs_menu = { path = "crates/vcs_menu" }
 vim = { path = "crates/vim" }
 welcome = { path = "crates/welcome" }
 workspace = { path = "crates/workspace" }
-worktree = { path = "crates/worktree" }
 zed = { path = "crates/zed" }
 zed_actions = { path = "crates/zed_actions" }

 alacritty_terminal = "0.23"
-any_vec = "0.13"
 anyhow = "1.0.57"
+any_vec = "0.13"
 ashpd = "0.8.0"
 async-compression = { version = "0.4", features = ["gzip", "futures-io"] }
 async-dispatcher = { version = "0.1"}
@@ -279,23 +279,20 @@ async-fs = "1.6"
 async-recursion = "1.0.0"
 async-tar = "0.4.2"
 async-trait = "0.1"
-async-watch = "0.3.1"
 async_zip = { version = "0.0.17", features = ["deflate", "deflate64"] }
-base64 = "0.13"
 bitflags = "2.4.2"
 blade-graphics = { git = "https://github.com/kvark/blade", rev = "21a56f780e21e4cb42c70a1dcf4b59842d1ad7f7" }
-blade-macros = { git = "https://github.com/kvark/blade", rev = "21a56f780e21e4cb42c70a1dcf4b59842d1ad7f7" }
-blade-util = { git = "https://github.com/kvark/blade", rev = "21a56f780e21e4cb42c70a1dcf4b59842d1ad7f7" }
+blade-macros = { git = "https://github.com/kvark/blade", rev =  "21a56f780e21e4cb42c70a1dcf4b59842d1ad7f7" }
+blade-util = { git = "https://github.com/kvark/blade", rev = "21a56f780e21e4cb42c70a1dcf4b59842d1ad7f7"  }
 cap-std = "3.0"
 cargo_toml = "0.20"
 chrono = { version = "0.4", features = ["serde"] }
 clap = { version = "4.4", features = ["derive"] }
 clickhouse = { version = "0.11.6" }
 cocoa = "0.25"
+ctor = "0.2.6"
 core-foundation = { version = "0.9.3" }
 core-foundation-sys = "0.8.6"
-ctor = "0.2.6"
-dashmap = "5.5.3"
 derive_more = "0.99.17"
 dirs = "4.0"
 emojis = "0.6.1"
@@ -311,7 +308,7 @@ heed = { version = "0.20.1", features = ["read-txn-no-tls"] }
 hex = "0.4.3"
 html5ever = "0.27.0"
 ignore = "0.4.22"
-image = "0.25.1"
+image = "0.23"
 indexmap = { version = "1.6.2", features = ["serde"] }
 indoc = "1"
 # We explicitly disable http2 support in isahc.
--- a/assets/fonts/plex-mono/ZedPlexMono-Bold.ttf
+++ b/assets/fonts/plex-mono/ZedPlexMono-Bold.ttf
--- a/assets/fonts/plex-mono/ZedPlexMono-BoldItalic.ttf
+++ b/assets/fonts/plex-mono/ZedPlexMono-BoldItalic.ttf
--- a/assets/fonts/plex-mono/ZedPlexMono-Italic.ttf
+++ b/assets/fonts/plex-mono/ZedPlexMono-Italic.ttf
--- a/assets/fonts/plex-mono/ZedPlexMono-Regular.ttf
+++ b/assets/fonts/plex-mono/ZedPlexMono-Regular.ttf
--- a/assets/fonts/plex-mono/license.txt
+++ b/assets/fonts/plex-mono/license.txt
@@ -1,92 +0,0 @@
-Copyright © 2017 IBM Corp. with Reserved Font Name "Plex"
-
-This Font Software is licensed under the SIL Open Font License, Version 1.1.
-This license is copied below, and is also available with a FAQ at:
-http://scripts.sil.org/OFL
-
-----------------------------------------------------------
-SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-----------------------------------------------------------
-
-PREAMBLE
-The goals of the Open Font License (OFL) are to stimulate worldwide
-development of collaborative font projects, to support the font creation
-efforts of academic and linguistic communities, and to provide a free and
-open framework in which fonts may be shared and improved in partnership
-with others.
-
-The OFL allows the licensed fonts to be used, studied, modified and
-redistributed freely as long as they are not sold by themselves. The
-fonts, including any derivative works, can be bundled, embedded, 
-redistributed and/or sold with any software provided that any reserved
-names are not used by derivative works. The fonts and derivatives,
-however, cannot be released under any other type of license. The
-requirement for fonts to remain under this license does not apply
-to any document created using the fonts or their derivatives.
-
-DEFINITIONS
-"Font Software" refers to the set of files released by the Copyright
-Holder(s) under this license and clearly marked as such. This may
-include source files, build scripts and documentation.
-
-"Reserved Font Name" refers to any names specified as such after the
-copyright statement(s).
-
-"Original Version" refers to the collection of Font Software components as
-distributed by the Copyright Holder(s).
-
-"Modified Version" refers to any derivative made by adding to, deleting,
-or substituting -- in part or in whole -- any of the components of the
-Original Version, by changing formats or by porting the Font Software to a
-new environment.
-
-"Author" refers to any designer, engineer, programmer, technical
-writer or other person who contributed to the Font Software.
-
-PERMISSION & CONDITIONS
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of the Font Software, to use, study, copy, merge, embed, modify,
-redistribute, and sell modified and unmodified copies of the Font
-Software, subject to the following conditions:
-
-1) Neither the Font Software nor any of its individual components,
-in Original or Modified Versions, may be sold by itself.
-
-2) Original or Modified Versions of the Font Software may be bundled,
-redistributed and/or sold with any software, provided that each copy
-contains the above copyright notice and this license. These can be
-included either as stand-alone text files, human-readable headers or
-in the appropriate machine-readable metadata fields within text or
-binary files as long as those fields can be easily viewed by the user.
-
-3) No Modified Version of the Font Software may use the Reserved Font
-Name(s) unless explicit written permission is granted by the corresponding
-Copyright Holder. This restriction only applies to the primary font name as
-presented to the users.
-
-4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
-Software shall not be used to promote, endorse or advertise any
-Modified Version, except to acknowledge the contribution(s) of the
-Copyright Holder(s) and the Author(s) or with their explicit written
-permission.
-
-5) The Font Software, modified or unmodified, in part or in whole,
-must be distributed entirely under this license, and must not be
-distributed under any other license. The requirement for fonts to
-remain under this license does not apply to any document created
-using the Font Software.
-
-TERMINATION
-This license becomes null and void if any of the above conditions are
-not met.
-
-DISCLAIMER
-THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
-DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
-OTHER DEALINGS IN THE FONT SOFTWARE.
--- a/assets/fonts/plex-sans/ZedPlexSans-Bold.ttf
+++ b/assets/fonts/plex-sans/ZedPlexSans-Bold.ttf
--- a/assets/fonts/plex-sans/ZedPlexSans-BoldItalic.ttf
+++ b/assets/fonts/plex-sans/ZedPlexSans-BoldItalic.ttf
--- a/assets/fonts/plex-sans/ZedPlexSans-Italic.ttf
+++ b/assets/fonts/plex-sans/ZedPlexSans-Italic.ttf
--- a/assets/fonts/plex-sans/ZedPlexSans-Regular.ttf
+++ b/assets/fonts/plex-sans/ZedPlexSans-Regular.ttf
--- a/assets/fonts/plex-sans/license.txt
+++ b/assets/fonts/plex-sans/license.txt
@@ -1,92 +0,0 @@
-Copyright © 2017 IBM Corp. with Reserved Font Name "Plex"
-
-This Font Software is licensed under the SIL Open Font License, Version 1.1.
-This license is copied below, and is also available with a FAQ at:
-http://scripts.sil.org/OFL
-
-----------------------------------------------------------
-SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-----------------------------------------------------------
-
-PREAMBLE
-The goals of the Open Font License (OFL) are to stimulate worldwide
-development of collaborative font projects, to support the font creation
-efforts of academic and linguistic communities, and to provide a free and
-open framework in which fonts may be shared and improved in partnership
-with others.
-
-The OFL allows the licensed fonts to be used, studied, modified and
-redistributed freely as long as they are not sold by themselves. The
-fonts, including any derivative works, can be bundled, embedded, 
-redistributed and/or sold with any software provided that any reserved
-names are not used by derivative works. The fonts and derivatives,
-however, cannot be released under any other type of license. The
-requirement for fonts to remain under this license does not apply
-to any document created using the fonts or their derivatives.
-
-DEFINITIONS
-"Font Software" refers to the set of files released by the Copyright
-Holder(s) under this license and clearly marked as such. This may
-include source files, build scripts and documentation.
-
-"Reserved Font Name" refers to any names specified as such after the
-copyright statement(s).
-
-"Original Version" refers to the collection of Font Software components as
-distributed by the Copyright Holder(s).
-
-"Modified Version" refers to any derivative made by adding to, deleting,
-or substituting -- in part or in whole -- any of the components of the
-Original Version, by changing formats or by porting the Font Software to a
-new environment.
-
-"Author" refers to any designer, engineer, programmer, technical
-writer or other person who contributed to the Font Software.
-
-PERMISSION & CONDITIONS
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of the Font Software, to use, study, copy, merge, embed, modify,
-redistribute, and sell modified and unmodified copies of the Font
-Software, subject to the following conditions:
-
-1) Neither the Font Software nor any of its individual components,
-in Original or Modified Versions, may be sold by itself.
-
-2) Original or Modified Versions of the Font Software may be bundled,
-redistributed and/or sold with any software, provided that each copy
-contains the above copyright notice and this license. These can be
-included either as stand-alone text files, human-readable headers or
-in the appropriate machine-readable metadata fields within text or
-binary files as long as those fields can be easily viewed by the user.
-
-3) No Modified Version of the Font Software may use the Reserved Font
-Name(s) unless explicit written permission is granted by the corresponding
-Copyright Holder. This restriction only applies to the primary font name as
-presented to the users.
-
-4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
-Software shall not be used to promote, endorse or advertise any
-Modified Version, except to acknowledge the contribution(s) of the
-Copyright Holder(s) and the Author(s) or with their explicit written
-permission.
-
-5) The Font Software, modified or unmodified, in part or in whole,
-must be distributed entirely under this license, and must not be
-distributed under any other license. The requirement for fonts to
-remain under this license does not apply to any document created
-using the Font Software.
-
-TERMINATION
-This license becomes null and void if any of the above conditions are
-not met.
-
-DISCLAIMER
-THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
-DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
-OTHER DEALINGS IN THE FONT SOFTWARE.
--- a/assets/fonts/zed-mono/zed-mono-extended.ttf
+++ b/assets/fonts/zed-mono/zed-mono-extended.ttf
--- a/assets/fonts/zed-mono/zed-mono-extendedbold.ttf
+++ b/assets/fonts/zed-mono/zed-mono-extendedbold.ttf
--- a/assets/fonts/zed-mono/zed-mono-extendedbolditalic.ttf
+++ b/assets/fonts/zed-mono/zed-mono-extendedbolditalic.ttf
--- a/assets/fonts/zed-mono/zed-mono-extendeditalic.ttf
+++ b/assets/fonts/zed-mono/zed-mono-extendeditalic.ttf
--- a/assets/fonts/zed-sans/zed-sans-extended.ttf
+++ b/assets/fonts/zed-sans/zed-sans-extended.ttf
--- a/assets/fonts/zed-sans/zed-sans-extendedbold.ttf
+++ b/assets/fonts/zed-sans/zed-sans-extendedbold.ttf
--- a/assets/fonts/zed-sans/zed-sans-extendedbolditalic.ttf
+++ b/assets/fonts/zed-sans/zed-sans-extendedbolditalic.ttf
--- a/assets/fonts/zed-sans/zed-sans-extendeditalic.ttf
+++ b/assets/fonts/zed-sans/zed-sans-extendeditalic.ttf
--- a/assets/icons/book.svg
+++ b/assets/icons/book.svg
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-book"><path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H20v20H6.5a2.5 2.5 0 0 1 0-5H20"/></svg>
--- a/assets/icons/book_copy.svg
+++ b/assets/icons/book_copy.svg
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-book-copy"><path d="M2 16V4a2 2 0 0 1 2-2h11"/><path d="M5 14H4a2 2 0 1 0 0 4h1"/><path d="M22 18H11a2 2 0 1 0 0 4h11V6H11a2 2 0 0 0-2 2v12"/></svg>
--- a/assets/icons/book_plus.svg
+++ b/assets/icons/book_plus.svg
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-book-plus"><path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H20v20H6.5a2.5 2.5 0 0 1 0-5H20"/><path d="M9 10h6"/><path d="M12 7v6"/></svg>
--- a/assets/icons/chevron_up_down.svg
+++ b/assets/icons/chevron_up_down.svg
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-chevrons-up-down"><path d="m7 15 5 5 5-5"/><path d="m7 9 5-5 5 5"/></svg>
--- a/assets/icons/file_icons/file_types.json
+++ b/assets/icons/file_icons/file_types.json
@@ -94,7 +94,6 @@
    "lua": "lua",
    "m4a": "audio",
    "m4v": "video",
-    "markdown": "document",
    "md": "document",
    "mdb": "storage",
    "mdf": "storage",
--- a/assets/icons/font.svg
+++ b/assets/icons/font.svg
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-type"><polyline points="4 7 4 4 20 4 20 7"/><line x1="9" x2="15" y1="20" y2="20"/><line x1="12" x2="12" y1="4" y2="20"/></svg>
--- a/assets/icons/font_size.svg
+++ b/assets/icons/font_size.svg
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-a-large-small"><path d="M21 14h-5"/><path d="M16 16v-3.5a2.5 2.5 0 0 1 5 0V16"/><path d="M4.5 13h6"/><path d="m3 16 4.5-9 4.5 9"/></svg>
--- a/assets/icons/font_weight.svg
+++ b/assets/icons/font_weight.svg
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-bold"><path d="M6 12h9a4 4 0 0 1 0 8H7a1 1 0 0 1-1-1V5a1 1 0 0 1 1-1h7a4 4 0 0 1 0 8"/></svg>
--- a/assets/icons/generic_close.svg
+++ b/assets/icons/generic_close.svg
@@ -1,4 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M11.5 4.5L4.5 11.5" stroke="black" stroke-linecap="square" stroke-linejoin="round"/>
-<path d="M4.5 4.5L11.5 11.5" stroke="black" stroke-linecap="square" stroke-linejoin="round"/>
-</svg>
--- a/assets/icons/generic_maximize.svg
+++ b/assets/icons/generic_maximize.svg
@@ -1,3 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M11.5 4.5H4.5V11.5H11.5V4.5Z" stroke="#FBF1C7"/>
-</svg>
--- a/assets/icons/generic_minimize.svg
+++ b/assets/icons/generic_minimize.svg
@@ -1,3 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M4 8H12" stroke="black"/>
-</svg>
--- a/assets/icons/generic_restore.svg
+++ b/assets/icons/generic_restore.svg
@@ -1,4 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M9.5 6.5H3.5V12.5H9.5V6.5Z" stroke="#FBF1C7"/>
-<path d="M10 8.5L12.5 8.5L12.5 3.5L7.5 3.5L7.5 6" stroke="#FBF1C7"/>
-</svg>
--- a/assets/icons/line_height.svg
+++ b/assets/icons/line_height.svg
@@ -1,6 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M4 13.6667H12" stroke="#B3B3B3" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round"/>
-<path d="M4 2.33333H12" stroke="#B3B3B3" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round"/>
-<path d="M5 11L8 5L11 11" stroke="#B3B3B3" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round"/>
-<path d="M6 9H10" stroke="#B3B3B3" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round"/>
-</svg>
--- a/assets/icons/visible.svg
+++ b/assets/icons/visible.svg
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-eye"><path d="M2 12s3-7 10-7 10 7 10 7-3 7-10 7-10-7-10-7Z"/><circle cx="12" cy="12" r="3"/></svg>
--- a/assets/keymaps/atom.json
+++ b/assets/keymaps/atom.json
@@ -11,8 +11,18 @@
      "cmd-b": "editor::GoToDefinition",
      "alt-cmd-b": "editor::GoToDefinitionSplit",
      "cmd-<": "editor::ScrollCursorCenter",
-      "cmd-g": ["editor::SelectNext", { "replace_newest": true }],
-      "ctrl-cmd-g": ["editor::SelectPrevious", { "replace_newest": true }],
+      "cmd-g": [
+        "editor::SelectNext",
+        {
+          "replace_newest": true
+        }
+      ],
+      "ctrl-cmd-g": [
+        "editor::SelectPrevious",
+        {
+          "replace_newest": true
+        }
+      ],
      "ctrl-shift-down": "editor::AddSelectionBelow",
      "ctrl-shift-up": "editor::AddSelectionAbove",
      "cmd-shift-backspace": "editor::DeleteToBeginningOfLine",
@@ -60,11 +70,6 @@
  {
    "context": "ProjectPanel",
    "bindings": {
-      "f2": "project_panel::Rename",
-      "backspace": ["project_panel::Trash", { "skip_prompt": false }],
-      "cmd-x": "project_panel::Cut",
-      "cmd-c": "project_panel::Copy",
-      "cmd-v": "project_panel::Paste",
      "ctrl-[": "project_panel::CollapseSelectedEntry",
      "ctrl-b": "project_panel::CollapseSelectedEntry",
      "alt-b": "project_panel::CollapseSelectedEntry",
@@ -72,13 +77,5 @@
      "ctrl-f": "project_panel::ExpandSelectedEntry",
      "ctrl-shift-c": "project_panel::CopyPath"
    }
-  },
-  {
-    "context": "ProjectPanel && not_editing",
-    "bindings": {
-      "a": "project_panel::NewFile",
-      "shift-a": "project_panel::NewDirectory",
-      "shift-d": "project_panel::Duplicate"
-    }
  }
 ]
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -44,7 +44,6 @@
      "ctrl-t": "editor::Transpose",
      "ctrl-backspace": "editor::DeleteToPreviousWordStart",
      "ctrl-delete": "editor::DeleteToNextWordEnd",
-      "shift-delete": "editor::Cut",
      "ctrl-x": "editor::Cut",
      "ctrl-insert": "editor::Copy",
      "ctrl-c": "editor::Copy",
@@ -56,13 +55,11 @@
      "up": "editor::MoveUp",
      "ctrl-up": "editor::LineUp",
      "ctrl-down": "editor::LineDown",
-      "pageup": "editor::MovePageUp",
-      "alt-pageup": "editor::PageUp",
+      "pageup": "editor::PageUp",
      "shift-pageup": "editor::SelectPageUp",
      "home": "editor::MoveToBeginningOfLine",
      "down": "editor::MoveDown",
-      "pagedown": "editor::MovePageDown",
-      "alt-pagedown": "editor::PageDown",
+      "pagedown": "editor::PageDown",
      "shift-pagedown": "editor::SelectPageDown",
      "end": "editor::MoveToEndOfLine",
      "left": "editor::MoveLeft",
@@ -84,13 +81,48 @@
      "ctrl-a": "editor::SelectAll",
      "ctrl-l": "editor::SelectLine",
      "ctrl-shift-i": "editor::Format",
-      // "cmd-shift-left": ["editor::SelectToBeginningOfLine", {"stop_at_soft_wraps": true }],
-      "shift-home": ["editor::SelectToBeginningOfLine", { "stop_at_soft_wraps": true }],
-      // "ctrl-shift-a": ["editor::SelectToBeginningOfLine", { "stop_at_soft_wraps": true }],
-      // "cmd-shift-right": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
-      "shift-end": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
-      // "ctrl-shift-e": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
-      // "alt-v": ["editor::MovePageUp", { "center_cursor": true }],
+      // "cmd-shift-left": [
+      //   "editor::SelectToBeginningOfLine",
+      //   {
+      //     "stop_at_soft_wraps": true
+      //   }
+      // ],
+      "shift-home": [
+        "editor::SelectToBeginningOfLine",
+        {
+          "stop_at_soft_wraps": true
+        }
+      ],
+      // "ctrl-shift-a": [
+      //   "editor::SelectToBeginningOfLine",
+      //   {
+      //     "stop_at_soft_wraps": true
+      //   }
+      // ],
+      // "cmd-shift-right": [
+      //   "editor::SelectToEndOfLine",
+      //   {
+      //     "stop_at_soft_wraps": true
+      //   }
+      // ],
+      "shift-end": [
+        "editor::SelectToEndOfLine",
+        {
+          "stop_at_soft_wraps": true
+        }
+      ],
+      // "ctrl-shift-e": [
+      //   "editor::SelectToEndOfLine",
+      //   {
+      //     "stop_at_soft_wraps": true
+      //   }
+      // ],
+      // "alt-v": [
+      //   "editor::MovePageUp",
+      //   {
+      //     "center_cursor": true
+      //   }
+      // ],
      "ctrl-alt-space": "editor::ShowCharacterPalette",
      "ctrl-;": "editor::ToggleLineNumbers",
      "ctrl-k ctrl-r": "editor::RevertSelectedHunks",
@@ -114,10 +146,13 @@
          "replace_enabled": true
        }
      ],
-      // "cmd-e": ["buffer_search::Deploy", { "focus": false }],
-      "ctrl->": "assistant::QuoteSelection",
-      "ctrl-<": "assistant::InsertIntoEditor",
-      "ctrl-alt-e": "editor::SelectEnclosingSymbol"
+      // "cmd-e": [
+      //   "buffer_search::Deploy",
+      //   {
+      //     "focus": false
+      //   }
+      // ],
+      "ctrl->": "assistant::QuoteSelection"
    }
  },
  {
@@ -271,13 +306,38 @@
      "ctrl-shift-right": "editor::SelectToNextWordEnd",
      "ctrl-shift-up": "editor::SelectLargerSyntaxNode", //todo(linux) tmp keybinding
      "ctrl-shift-down": "editor::SelectSmallerSyntaxNode", //todo(linux) tmp keybinding
-      "ctrl-d": ["editor::SelectNext", { "replace_newest": false }],
+      "ctrl-d": [
+        "editor::SelectNext",
+        {
+          "replace_newest": false
+        }
+      ],
      "ctrl-shift-l": "editor::SelectAllMatches",
-      "ctrl-shift-d": ["editor::SelectPrevious", { "replace_newest": false }],
-      "ctrl-k ctrl-d": ["editor::SelectNext", { "replace_newest": true }],
-      "ctrl-k ctrl-shift-d": ["editor::SelectPrevious", { "replace_newest": true }],
+      "ctrl-shift-d": [
+        "editor::SelectPrevious",
+        {
+          "replace_newest": false
+        }
+      ],
+      "ctrl-k ctrl-d": [
+        "editor::SelectNext",
+        {
+          "replace_newest": true
+        }
+      ],
+      "ctrl-k ctrl-shift-d": [
+        "editor::SelectPrevious",
+        {
+          "replace_newest": true
+        }
+      ],
      "ctrl-k ctrl-i": "editor::Hover",
-      "ctrl-/": ["editor::ToggleComments", { "advance_downwards": false }],
+      "ctrl-/": [
+        "editor::ToggleComments",
+        {
+          "advance_downwards": false
+        }
+      ],
      "ctrl-u": "editor::UndoSelection",
      "ctrl-shift-u": "editor::RedoSelection",
      "f8": "editor::GoToDiagnostic",
@@ -328,7 +388,12 @@
    "context": "Workspace",
    "bindings": {
      // Change the default action on `menu::Confirm` by setting the parameter
-      // "alt-cmd-o": ["projects::OpenRecent", { "create_new_window": true }],
+      // "alt-cmd-o": [
+      //     "projects::OpenRecent",
+      //     {
+      //         "create_new_window": true
+      //     }
+      // ]
      "alt-ctrl-o": "projects::OpenRecent",
      "alt-ctrl-shift-b": "branches::OpenRecent",
      "ctrl-~": "workspace::NewTerminal",
@@ -352,7 +417,12 @@
      "ctrl-j": "workspace::ToggleBottomDock",
      "ctrl-alt-y": "workspace::CloseAllDocks",
      "ctrl-shift-f": "pane::DeploySearch",
-      "ctrl-shift-h": ["pane::DeploySearch", { "replace_enabled": true }],
+      "ctrl-shift-h": [
+        "pane::DeploySearch",
+        {
+          "replace_enabled": true
+        }
+      ],
      "ctrl-k ctrl-s": "zed::OpenKeymap",
      "ctrl-k ctrl-t": "theme_selector::Toggle",
      "ctrl-shift-t": "project_symbols::Toggle",
@@ -475,7 +545,6 @@
      "ctrl-enter": "assistant::Assist",
      "ctrl-s": "workspace::Save",
      "ctrl->": "assistant::QuoteSelection",
-      "ctrl-<": "assistant::InsertIntoEditor",
      "shift-enter": "assistant::Split",
      "ctrl-r": "assistant::CycleMessageRole",
      "enter": "assistant::ConfirmCommand",
@@ -517,9 +586,8 @@
      "alt-ctrl-shift-c": "project_panel::CopyRelativePath",
      "f2": "project_panel::Rename",
      "enter": "project_panel::Rename",
-      "backspace": ["project_panel::Trash", { "skip_prompt": false }],
-      "shift-delete": ["project_panel::Delete", { "skip_prompt": false }],
-      "delete": ["project_panel::Trash", { "skip_prompt": false }],
+      "backspace": "project_panel::Trash",
+      "delete": "project_panel::Trash",
      "ctrl-backspace": ["project_panel::Delete", { "skip_prompt": false }],
      "ctrl-delete": ["project_panel::Delete", { "skip_prompt": false }],
      "alt-ctrl-r": "project_panel::RevealInFinder",
@@ -581,20 +649,13 @@
      "ctrl-insert": "terminal::Copy",
      "shift-ctrl-v": "terminal::Paste",
      "shift-insert": "terminal::Paste",
-      "ctrl-enter": "assistant::InlineAssist",
      "up": ["terminal::SendKeystroke", "up"],
      "pageup": ["terminal::SendKeystroke", "pageup"],
      "down": ["terminal::SendKeystroke", "down"],
      "pagedown": ["terminal::SendKeystroke", "pagedown"],
      "escape": ["terminal::SendKeystroke", "escape"],
      "enter": ["terminal::SendKeystroke", "enter"],
-      "ctrl-c": ["terminal::SendKeystroke", "ctrl-c"],
-      "shift-pageup": "terminal::ScrollPageUp",
-      "shift-pagedown": "terminal::ScrollPageDown",
-      "shift-up": "terminal::ScrollLineUp",
-      "shift-down": "terminal::ScrollLineDown",
-      "shift-home": "terminal::ScrollToTop",
-      "shift-end": "terminal::ScrollToBottom"
+      "ctrl-c": ["terminal::SendKeystroke", "ctrl-c"]
    }
  }
 ]
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -61,17 +61,13 @@
      "cmd-shift-z": "editor::Redo",
      "up": "editor::MoveUp",
      "ctrl-up": "editor::MoveToStartOfParagraph",
-      "pageup": "editor::MovePageUp",
-      "shift-pageup": "editor::SelectPageUp",
-      "cmd-pageup": "editor::PageUp",
-      "ctrl-pageup": "editor::LineUp",
+      "pageup": "editor::PageUp",
+      "shift-pageup": "editor::MovePageUp",
      "home": "editor::MoveToBeginningOfLine",
      "down": "editor::MoveDown",
      "ctrl-down": "editor::MoveToEndOfParagraph",
-      "pagedown": "editor::MovePageDown",
-      "shift-pagedown": "editor::SelectPageDown",
-      "cmd-pagedown": "editor::PageDown",
-      "ctrl-pagedown": "editor::LineDown",
+      "pagedown": "editor::PageDown",
+      "shift-pagedown": "editor::MovePageDown",
      "end": "editor::MoveToEndOfLine",
      "left": "editor::MoveLeft",
      "right": "editor::MoveRight",
@@ -109,14 +105,54 @@
      "cmd-a": "editor::SelectAll",
      "cmd-l": "editor::SelectLine",
      "cmd-shift-i": "editor::Format",
-      "cmd-shift-left": ["editor::SelectToBeginningOfLine", { "stop_at_soft_wraps": true }],
-      "shift-home": ["editor::SelectToBeginningOfLine", { "stop_at_soft_wraps": true }],
-      "ctrl-shift-a": ["editor::SelectToBeginningOfLine", { "stop_at_soft_wraps": true }],
-      "cmd-shift-right": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
-      "shift-end": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
-      "ctrl-shift-e": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
-      "ctrl-v": ["editor::MovePageDown", { "center_cursor": true }],
-      "alt-v": ["editor::MovePageUp", { "center_cursor": true }],
+      "cmd-shift-left": [
+        "editor::SelectToBeginningOfLine",
+        {
+          "stop_at_soft_wraps": true
+        }
+      ],
+      "shift-home": [
+        "editor::SelectToBeginningOfLine",
+        {
+          "stop_at_soft_wraps": true
+        }
+      ],
+      "ctrl-shift-a": [
+        "editor::SelectToBeginningOfLine",
+        {
+          "stop_at_soft_wraps": true
+        }
+      ],
+      "cmd-shift-right": [
+        "editor::SelectToEndOfLine",
+        {
+          "stop_at_soft_wraps": true
+        }
+      ],
+      "shift-end": [
+        "editor::SelectToEndOfLine",
+        {
+          "stop_at_soft_wraps": true
+        }
+      ],
+      "ctrl-shift-e": [
+        "editor::SelectToEndOfLine",
+        {
+          "stop_at_soft_wraps": true
+        }
+      ],
+      "ctrl-v": [
+        "editor::MovePageDown",
+        {
+          "center_cursor": true
+        }
+      ],
+      "alt-v": [
+        "editor::MovePageUp",
+        {
+          "center_cursor": true
+        }
+      ],
      "ctrl-cmd-space": "editor::ShowCharacterPalette",
      "cmd-;": "editor::ToggleLineNumbers",
      "cmd-alt-z": "editor::RevertSelectedHunks",
@@ -131,20 +167,28 @@
      "enter": "editor::Newline",
      "shift-enter": "editor::Newline",
      "cmd-shift-enter": "editor::NewlineAbove",
+      "cmd-enter": "editor::NewlineBelow",
      "alt-z": "editor::ToggleSoftWrap",
      "cmd-f": "buffer_search::Deploy",
-      "cmd-alt-f": ["buffer_search::Deploy", { "replace_enabled": true }],
-      "cmd-alt-l": ["buffer_search::Deploy", { "selection_search_enabled": true }],
-      "cmd-e": ["buffer_search::Deploy", { "focus": false }],
-      "cmd->": "assistant::QuoteSelection",
-      "cmd-<": "assistant::InsertIntoEditor",
-      "cmd-alt-e": "editor::SelectEnclosingSymbol"
-    }
-  },
-  {
-    "context": "Editor && mode == full && !jupyter",
-    "bindings": {
-      "cmd-enter": "editor::NewlineBelow"
+      "cmd-alt-f": [
+        "buffer_search::Deploy",
+        {
+          "replace_enabled": true
+        }
+      ],
+      "cmd-alt-l": [
+        "buffer_search::Deploy",
+        {
+          "selection_search_enabled": true
+        }
+      ],
+      "cmd-e": [
+        "buffer_search::Deploy",
+        {
+          "focus": false
+        }
+      ],
+      "cmd->": "assistant::QuoteSelection"
    }
  },
  {
@@ -189,7 +233,6 @@
      "cmd-enter": "assistant::Assist",
      "cmd-s": "workspace::Save",
      "cmd->": "assistant::QuoteSelection",
-      "cmd-<": "assistant::InsertIntoEditor",
      "shift-enter": "assistant::Split",
      "ctrl-r": "assistant::CycleMessageRole",
      "enter": "assistant::ConfirmCommand",
@@ -306,13 +349,38 @@
      "alt-shift-down": "editor::DuplicateLineDown",
      "ctrl-shift-right": "editor::SelectLargerSyntaxNode",
      "ctrl-shift-left": "editor::SelectSmallerSyntaxNode",
-      "cmd-d": ["editor::SelectNext", { "replace_newest": false }],
+      "cmd-d": [
+        "editor::SelectNext",
+        {
+          "replace_newest": false
+        }
+      ],
      "cmd-shift-l": "editor::SelectAllMatches",
-      "ctrl-cmd-d": ["editor::SelectPrevious", { "replace_newest": false }],
-      "cmd-k cmd-d": ["editor::SelectNext", { "replace_newest": true }],
-      "cmd-k ctrl-cmd-d": ["editor::SelectPrevious", { "replace_newest": true }],
+      "ctrl-cmd-d": [
+        "editor::SelectPrevious",
+        {
+          "replace_newest": false
+        }
+      ],
+      "cmd-k cmd-d": [
+        "editor::SelectNext",
+        {
+          "replace_newest": true
+        }
+      ],
+      "cmd-k ctrl-cmd-d": [
+        "editor::SelectPrevious",
+        {
+          "replace_newest": true
+        }
+      ],
      "cmd-k cmd-i": "editor::Hover",
-      "cmd-/": ["editor::ToggleComments", { "advance_downwards": false }],
+      "cmd-/": [
+        "editor::ToggleComments",
+        {
+          "advance_downwards": false
+        }
+      ],
      "cmd-u": "editor::UndoSelection",
      "cmd-shift-u": "editor::RedoSelection",
      "f8": "editor::GoToDiagnostic",
@@ -363,7 +431,12 @@
    "context": "Workspace",
    "bindings": {
      // Change the default action on `menu::Confirm` by setting the parameter
-      // "alt-cmd-o": ["projects::OpenRecent", {"create_new_window": true }],
+      // "alt-cmd-o": [
+      //     "projects::OpenRecent",
+      //     {
+      //         "create_new_window": true
+      //     }
+      // ]
      "alt-cmd-o": "projects::OpenRecent",
      "alt-cmd-b": "branches::OpenRecent",
      "ctrl-~": "workspace::NewTerminal",
@@ -387,7 +460,12 @@
      "cmd-j": "workspace::ToggleBottomDock",
      "alt-cmd-y": "workspace::CloseAllDocks",
      "cmd-shift-f": "pane::DeploySearch",
-      "cmd-shift-h": ["pane::DeploySearch", { "replace_enabled": true }],
+      "cmd-shift-h": [
+        "pane::DeploySearch",
+        {
+          "replace_enabled": true
+        }
+      ],
      "cmd-k cmd-s": "zed::OpenKeymap",
      "cmd-k cmd-t": "theme_selector::Toggle",
      "cmd-t": "project_symbols::Toggle",
@@ -526,7 +604,6 @@
      "left": "project_panel::CollapseSelectedEntry",
      "right": "project_panel::ExpandSelectedEntry",
      "cmd-n": "project_panel::NewFile",
-      "cmd-d": "project_panel::Duplicate",
      "alt-cmd-n": "project_panel::NewDirectory",
      "cmd-x": "project_panel::Cut",
      "cmd-c": "project_panel::Copy",
@@ -536,9 +613,8 @@
      "enter": "project_panel::Rename",
      "backspace": ["project_panel::Trash", { "skip_prompt": false }],
      "delete": ["project_panel::Trash", { "skip_prompt": false }],
-      "cmd-backspace": ["project_panel::Trash", { "skip_prompt": true }],
+      "cmd-backspace": ["project_panel::Delete", { "skip_prompt": false }],
      "cmd-delete": ["project_panel::Delete", { "skip_prompt": false }],
-      "cmd-alt-backspace": ["project_panel::Delete", { "skip_prompt": false }],
      "alt-cmd-r": "project_panel::RevealInFinder",
      "alt-shift-f": "project_panel::NewSearchInDirectory",
      "shift-down": "menu::SelectNext",
@@ -552,12 +628,6 @@
      "space": "project_panel::Open"
    }
  },
-  {
-    "context": "Editor && jupyter",
-    "bindings": {
-      "cmd-enter": "repl::Run"
-    }
-  },
  {
    "context": "CollabPanel && not_editing",
    "bindings": {
@@ -611,7 +681,6 @@
      "cmd-c": "terminal::Copy",
      "cmd-v": "terminal::Paste",
      "cmd-k": "terminal::Clear",
-      "ctrl-enter": "assistant::InlineAssist",
      // Some nice conveniences
      "cmd-backspace": ["terminal::SendText", "\u0015"],
      "cmd-right": ["terminal::SendText", "\u0005"],
@@ -627,13 +696,7 @@
      "pagedown": ["terminal::SendKeystroke", "pagedown"],
      "escape": ["terminal::SendKeystroke", "escape"],
      "enter": ["terminal::SendKeystroke", "enter"],
-      "ctrl-c": ["terminal::SendKeystroke", "ctrl-c"],
-      "shift-pageup": "terminal::ScrollPageUp",
-      "shift-pagedown": "terminal::ScrollPageDown",
-      "shift-up": "terminal::ScrollLineUp",
-      "shift-down": "terminal::ScrollLineDown",
-      "shift-home": "terminal::ScrollToTop",
-      "shift-end": "terminal::ScrollToBottom"
+      "ctrl-c": ["terminal::SendKeystroke", "ctrl-c"]
    }
  }
 ]
--- a/assets/keymaps/jetbrains.json
+++ b/assets/keymaps/jetbrains.json
@@ -21,9 +21,24 @@
      "cmd--": "editor::Fold",
      "cmd-+": "editor::UnfoldLines",
      "alt-shift-g": "editor::SplitSelectionIntoLines",
-      "ctrl-g": ["editor::SelectNext", { "replace_newest": false }],
-      "ctrl-cmd-g": ["editor::SelectPrevious", { "replace_newest": false }],
-      "cmd-/": ["editor::ToggleComments", { "advance_downwards": true }],
+      "ctrl-g": [
+        "editor::SelectNext",
+        {
+          "replace_newest": false
+        }
+      ],
+      "ctrl-cmd-g": [
+        "editor::SelectPrevious",
+        {
+          "replace_newest": false
+        }
+      ],
+      "cmd-/": [
+        "editor::ToggleComments",
+        {
+          "advance_downwards": true
+        }
+      ],
      "alt-up": "editor::SelectLargerSyntaxNode",
      "alt-down": "editor::SelectSmallerSyntaxNode",
      "shift-alt-up": "editor::MoveLineUp",
@@ -63,7 +78,6 @@
    "bindings": {
      "cmd-shift-o": "file_finder::Toggle",
      "cmd-shift-a": "command_palette::Toggle",
-      "shift shift": "command_palette::Toggle",
      "cmd-alt-o": "project_symbols::Toggle",
      "cmd-1": "workspace::ToggleLeftDock",
      "cmd-6": "diagnostics::Deploy"
@@ -80,10 +94,6 @@
    "context": "ProjectPanel",
    "bindings": {
      "enter": "project_panel::Open",
-      "cmd-backspace": ["project_panel::Trash", { "skip_prompt": false }],
-      "backspace": ["project_panel::Trash", { "skip_prompt": false }],
-      "delete": ["project_panel::Trash", { "skip_prompt": false }],
-      "shift-delete": ["project_panel::Delete", { "skip_prompt": false }],
      "shift-f6": "project_panel::Rename"
    }
  }
--- a/assets/keymaps/sublime_text.json
+++ b/assets/keymaps/sublime_text.json
@@ -19,7 +19,6 @@
      "ctrl-shift-m": "editor::SelectLargerSyntaxNode",
      "cmd-shift-l": "editor::SplitSelectionIntoLines",
      "cmd-shift-a": "editor::SelectLargerSyntaxNode",
-      "cmd-shift-d": "editor::DuplicateLineDown",
      "shift-f12": "editor::FindAllReferences",
      "alt-cmd-down": "editor::GoToDefinition",
      "ctrl-alt-cmd-down": "editor::GoToDefinitionSplit",
--- a/assets/keymaps/textmate.json
+++ b/assets/keymaps/textmate.json
@@ -22,14 +22,34 @@
      "alt-shift-delete": "editor::DeleteToNextWordEnd",
      "ctrl-backspace": "editor::DeleteToPreviousSubwordStart",
      "ctrl-delete": "editor::DeleteToNextSubwordEnd",
-      "alt-left": ["editor::MoveToPreviousWordStart", { "stop_at_soft_wraps": true }],
-      "alt-right": ["editor::MoveToNextWordEnd", { "stop_at_soft_wraps": true }],
+      "alt-left": [
+        "editor::MoveToPreviousWordStart",
+        {
+          "stop_at_soft_wraps": true
+        }
+      ],
+      "alt-right": [
+        "editor::MoveToNextWordEnd",
+        {
+          "stop_at_soft_wraps": true
+        }
+      ],
      "ctrl-left": "editor::MoveToPreviousSubwordStart",
      "ctrl-right": "editor::MoveToNextSubwordEnd",
      "cmd-shift-left": "editor::SelectToBeginningOfLine",
      "cmd-shift-right": "editor::SelectToEndOfLine",
-      "alt-shift-left": ["editor::SelectToPreviousWordStart", { "stop_at_soft_wraps": true }],
-      "alt-shift-right": ["editor::SelectToNextWordEnd", { "stop_at_soft_wraps": true }],
+      "alt-shift-left": [
+        "editor::SelectToPreviousWordStart",
+        {
+          "stop_at_soft_wraps": true
+        }
+      ],
+      "alt-shift-right": [
+        "editor::SelectToNextWordEnd",
+        {
+          "stop_at_soft_wraps": true
+        }
+      ],
      "ctrl-shift-left": "editor::SelectToPreviousSubwordStart",
      "ctrl-shift-right": "editor::SelectToNextSubwordEnd",
      "ctrl-w": "editor::SelectNext",
@@ -67,15 +87,7 @@
  },
  {
    "context": "ProjectPanel",
-    "bindings": {
-      "cmd-backspace": ["project_panel::Trash", { "skip_prompt": true }],
-      "cmd-d": "project_panel::Duplicate",
-      "cmd-n": "project_panel::NewFolder",
-      "return": "project_panel::Rename",
-      "cmd-c": "project_panel::Copy",
-      "cmd-v": "project_panel::Paste",
-      "cmd-alt-c": "project_panel::CopyPath"
-    }
+    "bindings": {}
  },
  {
    "context": "Dock",
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -8,8 +8,22 @@
  {
    "context": "Editor && VimControl && !VimWaiting && !menu",
    "bindings": {
-      "i": ["vim::PushOperator", { "Object": { "around": false } }],
-      "a": ["vim::PushOperator", { "Object": { "around": true } }],
+      "i": [
+        "vim::PushOperator",
+        {
+          "Object": {
+            "around": false
+          }
+        }
+      ],
+      "a": [
+        "vim::PushOperator",
+        {
+          "Object": {
+            "around": true
+          }
+        }
+      ],
      ":": "command_palette::Toggle",
      "h": "vim::Left",
      "left": "vim::Left",
@@ -33,32 +47,84 @@
      "{": "vim::StartOfParagraph",
      "}": "vim::EndOfParagraph",
      "|": "vim::GoToColumn",
+
      // Word motions
      "w": "vim::NextWordStart",
      "e": "vim::NextWordEnd",
      "b": "vim::PreviousWordStart",
      "g e": "vim::PreviousWordEnd",
+
      // Subword motions
      // "w": "vim::NextSubwordStart",
      // "b": "vim::PreviousSubwordStart",
      // "e": "vim::NextSubwordEnd",
      // "g e": "vim::PreviousSubwordEnd",
-      "shift-w": ["vim::NextWordStart", { "ignorePunctuation": true }],
-      "shift-e": ["vim::NextWordEnd", { "ignorePunctuation": true }],
-      "shift-b": ["vim::PreviousWordStart", { "ignorePunctuation": true }],
+
+      "shift-w": [
+        "vim::NextWordStart",
+        {
+          "ignorePunctuation": true
+        }
+      ],
+      "shift-e": [
+        "vim::NextWordEnd",
+        {
+          "ignorePunctuation": true
+        }
+      ],
+      "shift-b": [
+        "vim::PreviousWordStart",
+        {
+          "ignorePunctuation": true
+        }
+      ],
      "g shift-e": ["vim::PreviousWordEnd", { "ignorePunctuation": true }],
+
      "/": "vim::Search",
      "g /": "pane::DeploySearch",
-      "?": ["vim::Search", { "backwards": true }],
+      "?": [
+        "vim::Search",
+        {
+          "backwards": true
+        }
+      ],
      "*": "vim::MoveToNext",
      "#": "vim::MoveToPrev",
      "n": "vim::MoveToNextMatch",
      "shift-n": "vim::MoveToPrevMatch",
      "%": "vim::Matching",
-      "f": ["vim::PushOperator", { "FindForward": { "before": false } }],
-      "t": ["vim::PushOperator", { "FindForward": { "before": true } }],
-      "shift-f": ["vim::PushOperator", { "FindBackward": { "after": false } }],
-      "shift-t": ["vim::PushOperator", { "FindBackward": { "after": true } }],
+      "f": [
+        "vim::PushOperator",
+        {
+          "FindForward": {
+            "before": false
+          }
+        }
+      ],
+      "t": [
+        "vim::PushOperator",
+        {
+          "FindForward": {
+            "before": true
+          }
+        }
+      ],
+      "shift-f": [
+        "vim::PushOperator",
+        {
+          "FindBackward": {
+            "after": false
+          }
+        }
+      ],
+      "shift-t": [
+        "vim::PushOperator",
+        {
+          "FindBackward": {
+            "after": true
+          }
+        }
+      ],
      "m": ["vim::PushOperator", "Mark"],
      "'": ["vim::PushOperator", { "Jump": { "line": true } }],
      "`": ["vim::PushOperator", { "Jump": { "line": false } }],
@@ -98,25 +164,90 @@
      "g shift-n": "vim::SelectPreviousMatch",
      "g l": "vim::SelectNext",
      "g shift-l": "vim::SelectPrevious",
-      "g >": ["editor::SelectNext", { "replace_newest": true }],
-      "g <": ["editor::SelectPrevious", { "replace_newest": true }],
+      "g >": [
+        "editor::SelectNext",
+        {
+          "replace_newest": true
+        }
+      ],
+      "g <": [
+        "editor::SelectPrevious",
+        {
+          "replace_newest": true
+        }
+      ],
      "g a": "editor::SelectAllMatches",
      "g s": "outline::Toggle",
      "g shift-s": "project_symbols::Toggle",
      "g .": "editor::ToggleCodeActions", // zed specific
      "g shift-a": "editor::FindAllReferences", // zed specific
      "g space": "editor::OpenExcerpts", // zed specific
-      "g *": ["vim::MoveToNext", { "partialWord": true }],
-      "g #": ["vim::MoveToPrev", { "partialWord": true }],
-      "g j": ["vim::Down", { "displayLines": true }],
-      "g down": ["vim::Down", { "displayLines": true }],
-      "g k": ["vim::Up", { "displayLines": true }],
-      "g up": ["vim::Up", { "displayLines": true }],
-      "g $": ["vim::EndOfLine", { "displayLines": true }],
-      "g end": ["vim::EndOfLine", { "displayLines": true }],
-      "g 0": ["vim::StartOfLine", { "displayLines": true }],
-      "g home": ["vim::StartOfLine", { "displayLines": true }],
-      "g ^": ["vim::FirstNonWhitespace", { "displayLines": true }],
+      "g *": [
+        "vim::MoveToNext",
+        {
+          "partialWord": true
+        }
+      ],
+      "g #": [
+        "vim::MoveToPrev",
+        {
+          "partialWord": true
+        }
+      ],
+      "g j": [
+        "vim::Down",
+        {
+          "displayLines": true
+        }
+      ],
+      "g down": [
+        "vim::Down",
+        {
+          "displayLines": true
+        }
+      ],
+      "g k": [
+        "vim::Up",
+        {
+          "displayLines": true
+        }
+      ],
+      "g up": [
+        "vim::Up",
+        {
+          "displayLines": true
+        }
+      ],
+      "g $": [
+        "vim::EndOfLine",
+        {
+          "displayLines": true
+        }
+      ],
+      "g end": [
+        "vim::EndOfLine",
+        {
+          "displayLines": true
+        }
+      ],
+      "g 0": [
+        "vim::StartOfLine",
+        {
+          "displayLines": true
+        }
+      ],
+      "g home": [
+        "vim::StartOfLine",
+        {
+          "displayLines": true
+        }
+      ],
+      "g ^": [
+        "vim::FirstNonWhitespace",
+        {
+          "displayLines": true
+        }
+      ],
      "g v": "vim::RestoreVisualSelection",
      "g ]": "editor::GoToDiagnostic",
      "g [": "editor::GoToPrevDiagnostic",
@@ -134,8 +265,18 @@
      "z c": "editor::Fold",
      "z o": "editor::UnfoldLines",
      "z f": "editor::FoldSelectedRanges",
-      "shift-z shift-q": ["pane::CloseActiveItem", { "saveIntent": "skip" }],
-      "shift-z shift-z": ["pane::CloseActiveItem", { "saveIntent": "saveAll" }],
+      "shift-z shift-q": [
+        "pane::CloseActiveItem",
+        {
+          "saveIntent": "skip"
+        }
+      ],
+      "shift-z shift-z": [
+        "pane::CloseActiveItem",
+        {
+          "saveIntent": "saveAll"
+        }
+      ],
      // Count support
      "1": ["vim::Number", 1],
      "2": ["vim::Number", 2],
@@ -190,6 +331,7 @@
      "ctrl-w ctrl-o": "workspace::CloseInactiveTabsAndPanes",
      "ctrl-w n": ["workspace::NewFileInDirection", "Up"],
      "ctrl-w ctrl-n": ["workspace::NewFileInDirection", "Up"],
+
      "ctrl-w d": "editor::GoToDefinitionSplit",
      "ctrl-w g d": "editor::GoToDefinitionSplit",
      "ctrl-w shift-d": "editor::GoToTypeDefinitionSplit",
@@ -230,7 +372,12 @@
      "ctrl-a": "vim::Increment",
      "ctrl-x": "vim::Decrement",
      "p": "vim::Paste",
-      "shift-p": ["vim::Paste", { "before": true }],
+      "shift-p": [
+        "vim::Paste",
+        {
+          "before": true
+        }
+      ],
      "u": "editor::Undo",
      "ctrl-r": "editor::Redo",
      "r": ["vim::PushOperator", "Replace"],
@@ -242,9 +389,6 @@
      "g shift-u": ["vim::PushOperator", "Uppercase"],
      "g ~": ["vim::PushOperator", "OppositeCase"],
      "\"": ["vim::PushOperator", "Register"],
-      "q": "vim::ToggleRecord",
-      "shift-q": "vim::ReplayLastRecording",
-      "@": ["vim::PushOperator", "ReplayRegister"],
      "ctrl-pagedown": "pane::ActivateNextItem",
      "ctrl-pageup": "pane::ActivatePrevItem",
      // tree-sitter related commands
@@ -281,7 +425,12 @@
  {
    "context": "Editor && vim_mode == normal && vim_operator == c",
    "bindings": {
-      "s": ["vim::PushOperator", { "ChangeSurrounds": {} }]
+      "s": [
+        "vim::PushOperator",
+        {
+          "ChangeSurrounds": {}
+        }
+      ]
    }
  },
  {
@@ -326,7 +475,12 @@
  {
    "context": "Editor && vim_mode == normal && vim_operator == y",
    "bindings": {
-      "s": ["vim::PushOperator", { "AddSurrounds": {} }]
+      "s": [
+        "vim::PushOperator",
+        {
+          "AddSurrounds": {}
+        }
+      ]
    }
  },
  {
@@ -351,7 +505,12 @@
    "context": "Editor && VimObject",
    "bindings": {
      "w": "vim::Word",
-      "shift-w": ["vim::Word", { "ignorePunctuation": true }],
+      "shift-w": [
+        "vim::Word",
+        {
+          "ignorePunctuation": true
+        }
+      ],
      "t": "vim::Tag",
      "s": "vim::Sentence",
      "p": "vim::Paragraph",
@@ -386,18 +545,43 @@
      "y": "vim::VisualYank",
      "shift-y": "vim::VisualYank",
      "p": "vim::Paste",
-      "shift-p": ["vim::Paste", { "preserveClipboard": true }],
+      "shift-p": [
+        "vim::Paste",
+        {
+          "preserveClipboard": true
+        }
+      ],
      "s": "vim::Substitute",
      "shift-s": "vim::SubstituteLine",
      "shift-r": "vim::SubstituteLine",
      "c": "vim::Substitute",
      "~": "vim::ChangeCase",
-      "*": ["vim::MoveToNext", { "partialWord": true }],
-      "#": ["vim::MoveToPrev", { "partialWord": true }],
+      "*": [
+        "vim::MoveToNext",
+        {
+          "partialWord": true
+        }
+      ],
+      "#": [
+        "vim::MoveToPrev",
+        {
+          "partialWord": true
+        }
+      ],
      "ctrl-a": "vim::Increment",
      "ctrl-x": "vim::Decrement",
-      "g ctrl-a": ["vim::Increment", { "step": true }],
-      "g ctrl-x": ["vim::Decrement", { "step": true }],
+      "g ctrl-a": [
+        "vim::Increment",
+        {
+          "step": true
+        }
+      ],
+      "g ctrl-x": [
+        "vim::Decrement",
+        {
+          "step": true
+        }
+      ],
      "shift-i": "vim::InsertBefore",
      "shift-a": "vim::InsertAfter",
      "shift-j": "vim::JoinLines",
@@ -407,8 +591,22 @@
      "ctrl-[": ["vim::SwitchMode", "Normal"],
      ">": "vim::Indent",
      "<": "vim::Outdent",
-      "i": ["vim::PushOperator", { "Object": { "around": false } }],
-      "a": ["vim::PushOperator", { "Object": { "around": true } }]
+      "i": [
+        "vim::PushOperator",
+        {
+          "Object": {
+            "around": false
+          }
+        }
+      ],
+      "a": [
+        "vim::PushOperator",
+        {
+          "Object": {
+            "around": true
+          }
+        }
+      ]
    }
  },
  {
@@ -478,8 +676,7 @@
  {
    "context": "EmptyPane || SharedScreen",
    "bindings": {
-      ":": "command_palette::Toggle",
-      "g /": "pane::DeploySearch"
+      ":": "command_palette::Toggle"
    }
  },
  {
@@ -507,14 +704,5 @@
      "g g": "menu::SelectFirst",
      "-": "project_panel::SelectParent"
    }
-  },
-  {
-    "context": "OutlinePanel",
-    "bindings": {
-      "j": "menu::SelectNext",
-      "k": "menu::SelectPrev",
-      "shift-g": "menu::SelectLast",
-      "g g": "menu::SelectFirst"
-    }
  }
 ]
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -1,15 +1,19 @@
 {
  // The name of the Zed theme to use for the UI.
  //
-  // `mode` is one of:
+  // The theme can also be set to follow system preferences:
+  //
+  // "theme": {
+  //   "mode": "system",
+  //   "light": "One Light",
+  //   "dark": "One Dark"
+  // }
+  //
+  // Where `mode` is one of:
  // - "system": Use the theme that corresponds to the system's appearance
  // - "light": Use the theme indicated by the "light" field
  // - "dark": Use the theme indicated by the "dark" field
-  "theme": {
-    "mode": "system",
-    "light": "One Light",
-    "dark": "One Dark"
-  },
+  "theme": "One Dark",
  // The name of a base set of key bindings to use.
  // This setting can take four values, each named after another
  // text editor:
@@ -25,7 +29,7 @@
    "inline_completion_provider": "copilot"
  },
  // The name of a font to use for rendering text in the editor
-  "buffer_font_family": "Zed Plex Mono",
+  "buffer_font_family": "Zed Mono",
  // The OpenType features to enable for text in the editor.
  "buffer_font_features": {
    // Disable ligatures:
@@ -38,17 +42,16 @@
  // Set the buffer's line height.
  // May take 3 values:
  //  1. Use a line height that's comfortable for reading (1.618)
-  //         "buffer_line_height": "comfortable"
+  //         "line_height": "comfortable"
  //  2. Use a standard line height, (1.3)
-  //         "buffer_line_height": "standard",
+  //         "line_height": "standard",
  //  3. Use a custom line height
-  //         "buffer_line_height": {
+  //         "line_height": {
  //           "custom": 2
  //         },
  "buffer_line_height": "comfortable",
  // The name of a font to use for rendering text in the UI
-  // (On macOS) You can set this to ".SysmtemUIFont" to use the system font
-  "ui_font_family": "Zed Plex Sans",
+  "ui_font_family": ".SystemUIFont",
  // The OpenType features to enable for text in the UI
  "ui_font_features": {
    // Disable ligatures:
@@ -162,11 +165,11 @@
  // 1. Draw tabs and spaces only for the selected text (default):
  //    "selection"
  // 2. Do not draw any tabs or spaces:
-  //    "none"
+  //   "none"
  // 3. Draw all invisible symbols:
-  //    "all"
+  //   "all"
  // 4. Draw whitespaces at boundaries only:
-  //    "boundary"
+  //   "boundaries"
  // For a whitespace to be on a boundary, any of the following conditions need to be met:
  // - It is a tab
  // - It is adjacent to an edge (start or end)
@@ -307,8 +310,8 @@
    // when a corresponding project entry becomes active.
    // Gitignored entries are never auto revealed.
    "auto_reveal_entries": true,
-    // Whether to fold directories automatically and show compact folders
-    // (e.g. "a/b/c" ) when a directory has only one subdirectory inside.
+    /// Whether to fold directories automatically
+    /// when a directory has only one directory inside.
    "auto_fold_dirs": false,
    /// Scrollbar-related settings
    "scrollbar": {
@@ -666,17 +669,13 @@
    // "font_size": 15,
    // Set the terminal's font family. If this option is not included,
    // the terminal will default to matching the buffer's font family.
-    // "font_family": "Zed Plex Mono",
+    // "font_family": "Zed Mono",
    // Sets the maximum number of lines in the terminal's scrollback buffer.
    // Default: 10_000, maximum: 100_000 (all bigger values set will be treated as 100_000), 0 disables the scrolling.
    // Existing terminals will not pick up this change until they are recreated.
    // "max_scroll_history_lines": 10000,
  },
  "code_actions_on_format": {},
-  /// Settings related to running tasks.
-  "tasks": {
-    "variables": {}
-  },
  // An object whose keys are language names, and whose values
  // are arrays of filenames or extensions of files that should
  // use those languages.
@@ -689,10 +688,7 @@
  //   "TOML": ["Embargo.lock"]
  // }
  //
-  "file_types": {
-    "JSON": ["flake.lock"],
-    "JSONC": ["**/.zed/**/*.json", "**/zed/**/*.json"]
-  },
+  "file_types": {},
  // The extensions that Zed should automatically install on startup.
  //
  // If you don't want any of these extensions, add this field to your settings
@@ -762,11 +758,6 @@
        "allowed": true
      }
    },
-    "JSONC": {
-      "prettier": {
-        "allowed": true
-      }
-    },
    "Markdown": {
      "format_on_save": "off",
      "prettier": {
@@ -776,8 +767,7 @@
    "PHP": {
      "prettier": {
        "allowed": true,
-        "plugins": ["@prettier/plugin-php"],
-        "parser": "php"
+        "plugins": ["@prettier/plugin-php"]
      }
    },
    "Ruby": {
--- a/assets/settings/initial_user_settings.json
+++ b/assets/settings/initial_user_settings.json
@@ -8,10 +8,5 @@
 // from the command palette or from `Zed` application menu.
 {
  "ui_font_size": 16,
-  "buffer_font_size": 16,
-  "theme": {
-    "mode": "system",
-    "light": "One Light",
-    "dark": "One Dark"
-  }
+  "buffer_font_size": 16
 }
--- a/crates/assets/src/assets.rs
+++ b/crates/assets/src/assets.rs
@@ -52,13 +52,4 @@ impl Assets {

        cx.text_system().add_fonts(embedded_fonts)
    }
-
-    pub fn load_test_fonts(&self, cx: &AppContext) {
-        cx.text_system()
-            .add_fonts(vec![self
-                .load("fonts/plex-mono/ZedPlexMono-Regular.ttf")
-                .unwrap()
-                .unwrap()])
-            .unwrap()
-    }
 }
--- a/crates/assistant/Cargo.toml
+++ b/crates/assistant/Cargo.toml
@@ -13,18 +13,17 @@ path = "src/assistant.rs"
 doctest = false

 [dependencies]
-anthropic = { workspace = true, features = ["schemars"] }
 anyhow.workspace = true
+anthropic = { workspace = true, features = ["schemars"] }
 assistant_slash_command.workspace = true
 async-watch.workspace = true
-breadcrumbs.workspace = true
 cargo_toml.workspace = true
 chrono.workspace = true
 client.workspace = true
 collections.workspace = true
 command_palette_hooks.workspace = true
 editor.workspace = true
-feature_flags.workspace = true
+file_icons.workspace = true
 fs.workspace = true
 futures.workspace = true
 fuzzy.workspace = true
@@ -32,7 +31,6 @@ gpui.workspace = true
 heed.workspace = true
 html_to_markdown.workspace = true
 http.workspace = true
-indexed_docs.workspace = true
 indoc.workspace = true
 language.workspace = true
 log.workspace = true
@@ -46,6 +44,7 @@ paths.workspace = true
 project.workspace = true
 regex.workspace = true
 rope.workspace = true
+rustdoc.workspace = true
 schemars.workspace = true
 search.workspace = true
 semantic_index.workspace = true
@@ -57,7 +56,6 @@ smol.workspace = true
 strsim = "0.11"
 strum.workspace = true
 telemetry_events.workspace = true
-terminal.workspace = true
 terminal_view.workspace = true
 theme.workspace = true
 tiktoken-rs.workspace = true
--- a/crates/assistant/src/assistant.rs
+++ b/crates/assistant/src/assistant.rs
@@ -9,27 +9,25 @@ mod prompts;
 mod search;
 mod slash_command;
 mod streaming_diff;
-mod terminal_inline_assistant;

-pub use assistant_panel::{AssistantPanel, AssistantPanelEvent};
+pub use assistant_panel::AssistantPanel;
+
 use assistant_settings::{AnthropicModel, AssistantSettings, CloudModel, OllamaModel, OpenAiModel};
 use assistant_slash_command::SlashCommandRegistry;
 use client::{proto, Client};
 use command_palette_hooks::CommandPaletteFilter;
 pub(crate) use completion_provider::*;
 pub(crate) use context_store::*;
-use fs::Fs;
 use gpui::{actions, AppContext, Global, SharedString, UpdateGlobal};
-use indexed_docs::IndexedDocsRegistry;
 pub(crate) use inline_assistant::*;
 pub(crate) use model_selector::*;
+use rustdoc::RustdocStore;
 use semantic_index::{CloudEmbeddingProvider, SemanticIndex};
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsStore};
 use slash_command::{
-    active_command, default_command, diagnostics_command, docs_command, fetch_command,
-    file_command, now_command, project_command, prompt_command, search_command, tabs_command,
-    term_command,
+    active_command, default_command, diagnostics_command, fetch_command, file_command, now_command,
+    project_command, prompt_command, rustdoc_command, search_command, tabs_command, term_command,
 };
 use std::{
    fmt::{self, Display},
@@ -44,13 +42,11 @@ actions!(
        Split,
        CycleMessageRole,
        QuoteSelection,
-        InsertIntoEditor,
        ToggleFocus,
        ResetKey,
        InlineAssist,
        InsertActivePrompt,
-        DeployHistory,
-        DeployPromptLibrary,
+        ToggleHistory,
        ApplyEdit,
        ConfirmCommand,
        ToggleModelSelector
@@ -163,7 +159,7 @@ impl LanguageModelRequestMessage {
    }
 }

-#[derive(Debug, Default, Serialize, Deserialize)]
+#[derive(Debug, Default, Serialize)]
 pub struct LanguageModelRequest {
    pub model: LanguageModel,
    pub messages: Vec<LanguageModelRequestMessage>,
@@ -268,7 +264,7 @@ impl Assistant {
    }
 }

-pub fn init(fs: Arc<dyn Fs>, client: Arc<Client>, cx: &mut AppContext) {
+pub fn init(client: Arc<Client>, cx: &mut AppContext) {
    cx.set_global(Assistant::default());
    AssistantSettings::register(cx);

@@ -292,9 +288,8 @@ pub fn init(fs: Arc<dyn Fs>, client: Arc<Client>, cx: &mut AppContext) {
    assistant_slash_command::init(cx);
    register_slash_commands(cx);
    assistant_panel::init(cx);
-    inline_assistant::init(fs.clone(), client.telemetry().clone(), cx);
-    terminal_inline_assistant::init(fs.clone(), client.telemetry().clone(), cx);
-    IndexedDocsRegistry::init_global(cx);
+    inline_assistant::init(client.telemetry().clone(), cx);
+    RustdocStore::init_global(cx);

    CommandPaletteFilter::update_global(cx, |filter, _cx| {
        filter.hide_namespace(Assistant::NAMESPACE);
@@ -324,29 +319,11 @@ fn register_slash_commands(cx: &mut AppContext) {
    slash_command_registry.register_command(default_command::DefaultSlashCommand, true);
    slash_command_registry.register_command(term_command::TermSlashCommand, true);
    slash_command_registry.register_command(now_command::NowSlashCommand, true);
-    slash_command_registry.register_command(diagnostics_command::DiagnosticsSlashCommand, true);
-    slash_command_registry.register_command(docs_command::DocsSlashCommand, true);
+    slash_command_registry.register_command(diagnostics_command::DiagnosticsCommand, true);
+    slash_command_registry.register_command(rustdoc_command::RustdocSlashCommand, false);
    slash_command_registry.register_command(fetch_command::FetchSlashCommand, false);
 }

-pub fn humanize_token_count(count: usize) -> String {
-    match count {
-        0..=999 => count.to_string(),
-        1000..=9999 => {
-            let thousands = count / 1000;
-            let hundreds = (count % 1000 + 50) / 100;
-            if hundreds == 0 {
-                format!("{}k", thousands)
-            } else if hundreds == 10 {
-                format!("{}k", thousands + 1)
-            } else {
-                format!("{}.{}k", thousands, hundreds)
-            }
-        }
-        _ => format!("{}k", (count + 500) / 1000),
-    }
-}
-
 #[cfg(test)]
 #[ctor::ctor]
 fn init_logger() {
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
--- a/crates/assistant/src/assistant_settings.rs
+++ b/crates/assistant/src/assistant_settings.rs
@@ -1,6 +1,5 @@
 use std::fmt;

-use crate::{preprocess_anthropic_request, LanguageModel, LanguageModelRequest};
 pub use anthropic::Model as AnthropicModel;
 use gpui::Pixels;
 pub use ollama::Model as OllamaModel;
@@ -16,6 +15,8 @@ use serde::{
 use settings::{Settings, SettingsSources};
 use strum::{EnumIter, IntoEnumIterator};

+use crate::{preprocess_anthropic_request, LanguageModel, LanguageModelRequest};
+
 #[derive(Clone, Debug, Default, PartialEq, EnumIter)]
 pub enum CloudModel {
    Gpt3Point5Turbo,
@@ -168,7 +169,6 @@ pub enum AssistantProvider {
        model: OpenAiModel,
        api_url: String,
        low_speed_timeout_in_seconds: Option<u64>,
-        available_models: Vec<OpenAiModel>,
    },
    Anthropic {
        model: AnthropicModel,
@@ -188,7 +188,6 @@ impl Default for AssistantProvider {
            model: OpenAiModel::default(),
            api_url: open_ai::OPEN_AI_API_URL.into(),
            low_speed_timeout_in_seconds: None,
-            available_models: Default::default(),
        }
    }
 }
@@ -203,7 +202,6 @@ pub enum AssistantProviderContent {
        default_model: Option<OpenAiModel>,
        api_url: Option<String>,
        low_speed_timeout_in_seconds: Option<u64>,
-        available_models: Option<Vec<OpenAiModel>>,
    },
    #[serde(rename = "anthropic")]
    Anthropic {
@@ -274,7 +272,6 @@ impl AssistantSettingsContent {
                        default_model: settings.default_open_ai_model.clone(),
                        api_url: Some(open_ai_api_url.clone()),
                        low_speed_timeout_in_seconds: None,
-                        available_models: Some(Default::default()),
                    })
                } else {
                    settings.default_open_ai_model.clone().map(|open_ai_model| {
@@ -282,7 +279,6 @@ impl AssistantSettingsContent {
                            default_model: Some(open_ai_model),
                            api_url: None,
                            low_speed_timeout_in_seconds: None,
-                            available_models: Some(Default::default()),
                        }
                    })
                },
@@ -330,14 +326,6 @@ impl AssistantSettingsContent {
                            *model = Some(new_model);
                        }
                    }
-                    Some(AssistantProviderContent::Ollama {
-                        default_model: model,
-                        ..
-                    }) => {
-                        if let LanguageModel::Ollama(new_model) = new_model {
-                            *model = Some(new_model);
-                        }
-                    }
                    provider => match new_model {
                        LanguageModel::Cloud(model) => {
                            *provider = Some(AssistantProviderContent::ZedDotDev {
@@ -349,7 +337,6 @@ impl AssistantSettingsContent {
                                default_model: Some(model),
                                api_url: None,
                                low_speed_timeout_in_seconds: None,
-                                available_models: Some(Default::default()),
                            })
                        }
                        LanguageModel::Anthropic(model) => {
@@ -494,18 +481,15 @@ impl Settings for AssistantSettings {
                            model,
                            api_url,
                            low_speed_timeout_in_seconds,
-                            available_models,
                        },
                        AssistantProviderContent::OpenAi {
                            default_model: model_override,
                            api_url: api_url_override,
                            low_speed_timeout_in_seconds: low_speed_timeout_in_seconds_override,
-                            available_models: available_models_override,
                        },
                    ) => {
                        merge(model, model_override);
                        merge(api_url, api_url_override);
-                        merge(available_models, available_models_override);
                        if let Some(low_speed_timeout_in_seconds_override) =
                            low_speed_timeout_in_seconds_override
                        {
@@ -566,12 +550,10 @@ impl Settings for AssistantSettings {
                                default_model: model,
                                api_url,
                                low_speed_timeout_in_seconds,
-                                available_models,
                            } => AssistantProvider::OpenAi {
                                model: model.unwrap_or_default(),
                                api_url: api_url.unwrap_or_else(|| open_ai::OPEN_AI_API_URL.into()),
                                low_speed_timeout_in_seconds,
-                                available_models: available_models.unwrap_or_default(),
                            },
                            AssistantProviderContent::Anthropic {
                                default_model: model,
@@ -628,7 +610,6 @@ mod tests {
                model: OpenAiModel::FourOmni,
                api_url: open_ai::OPEN_AI_API_URL.into(),
                low_speed_timeout_in_seconds: None,
-                available_models: Default::default(),
            }
        );

@@ -651,7 +632,6 @@ mod tests {
                model: OpenAiModel::FourOmni,
                api_url: "test-url".into(),
                low_speed_timeout_in_seconds: None,
-                available_models: Default::default(),
            }
        );
        SettingsStore::update_global(cx, |store, cx| {
@@ -672,7 +652,6 @@ mod tests {
                model: OpenAiModel::Four,
                api_url: open_ai::OPEN_AI_API_URL.into(),
                low_speed_timeout_in_seconds: None,
-                available_models: Default::default(),
            }
        );

--- a/crates/assistant/src/completion_provider.rs
+++ b/crates/assistant/src/completion_provider.rs
@@ -11,8 +11,6 @@ pub use cloud::*;
 pub use fake::*;
 pub use ollama::*;
 pub use open_ai::*;
-use parking_lot::RwLock;
-use smol::lock::{Semaphore, SemaphoreGuardArc};

 use crate::{
    assistant_settings::{AssistantProvider, AssistantSettings},
@@ -23,135 +21,177 @@ use client::Client;
 use futures::{future::BoxFuture, stream::BoxStream};
 use gpui::{AnyView, AppContext, BorrowAppContext, Task, WindowContext};
 use settings::{Settings, SettingsStore};
+use std::sync::Arc;
 use std::time::Duration;
-use std::{any::Any, sync::Arc};
-
-/// Choose which model to use for openai provider.
-/// If the model is not available, try to use the first available model, or fallback to the original model.
-fn choose_openai_model(
-    model: &::open_ai::Model,
-    available_models: &[::open_ai::Model],
-) -> ::open_ai::Model {
-    available_models
-        .iter()
-        .find(|&m| m == model)
-        .or_else(|| available_models.first())
-        .unwrap_or_else(|| model)
-        .clone()
-}

 pub fn init(client: Arc<Client>, cx: &mut AppContext) {
-    let provider = create_provider_from_settings(client.clone(), 0, cx);
-    cx.set_global(CompletionProvider::new(provider, Some(client)));
-
    let mut settings_version = 0;
+    let provider = match &AssistantSettings::get_global(cx).provider {
+        AssistantProvider::ZedDotDev { model } => CompletionProvider::Cloud(
+            CloudCompletionProvider::new(model.clone(), client.clone(), settings_version, cx),
+        ),
+        AssistantProvider::OpenAi {
+            model,
+            api_url,
+            low_speed_timeout_in_seconds,
+        } => CompletionProvider::OpenAi(OpenAiCompletionProvider::new(
+            model.clone(),
+            api_url.clone(),
+            client.http_client(),
+            low_speed_timeout_in_seconds.map(Duration::from_secs),
+            settings_version,
+        )),
+        AssistantProvider::Anthropic {
+            model,
+            api_url,
+            low_speed_timeout_in_seconds,
+        } => CompletionProvider::Anthropic(AnthropicCompletionProvider::new(
+            model.clone(),
+            api_url.clone(),
+            client.http_client(),
+            low_speed_timeout_in_seconds.map(Duration::from_secs),
+            settings_version,
+        )),
+        AssistantProvider::Ollama {
+            model,
+            api_url,
+            low_speed_timeout_in_seconds,
+        } => CompletionProvider::Ollama(OllamaCompletionProvider::new(
+            model.clone(),
+            api_url.clone(),
+            client.http_client(),
+            low_speed_timeout_in_seconds.map(Duration::from_secs),
+            settings_version,
+            cx,
+        )),
+    };
+    cx.set_global(provider);
+
    cx.observe_global::<SettingsStore>(move |cx| {
        settings_version += 1;
        cx.update_global::<CompletionProvider, _>(|provider, cx| {
-            provider.update_settings(settings_version, cx);
+            match (&mut *provider, &AssistantSettings::get_global(cx).provider) {
+                (
+                    CompletionProvider::OpenAi(provider),
+                    AssistantProvider::OpenAi {
+                        model,
+                        api_url,
+                        low_speed_timeout_in_seconds,
+                    },
+                ) => {
+                    provider.update(
+                        model.clone(),
+                        api_url.clone(),
+                        low_speed_timeout_in_seconds.map(Duration::from_secs),
+                        settings_version,
+                    );
+                }
+                (
+                    CompletionProvider::Anthropic(provider),
+                    AssistantProvider::Anthropic {
+                        model,
+                        api_url,
+                        low_speed_timeout_in_seconds,
+                    },
+                ) => {
+                    provider.update(
+                        model.clone(),
+                        api_url.clone(),
+                        low_speed_timeout_in_seconds.map(Duration::from_secs),
+                        settings_version,
+                    );
+                }
+
+                (
+                    CompletionProvider::Ollama(provider),
+                    AssistantProvider::Ollama {
+                        model,
+                        api_url,
+                        low_speed_timeout_in_seconds,
+                    },
+                ) => {
+                    provider.update(
+                        model.clone(),
+                        api_url.clone(),
+                        low_speed_timeout_in_seconds.map(Duration::from_secs),
+                        settings_version,
+                        cx,
+                    );
+                }
+
+                (CompletionProvider::Cloud(provider), AssistantProvider::ZedDotDev { model }) => {
+                    provider.update(model.clone(), settings_version);
+                }
+                (_, AssistantProvider::ZedDotDev { model }) => {
+                    *provider = CompletionProvider::Cloud(CloudCompletionProvider::new(
+                        model.clone(),
+                        client.clone(),
+                        settings_version,
+                        cx,
+                    ));
+                }
+                (
+                    _,
+                    AssistantProvider::OpenAi {
+                        model,
+                        api_url,
+                        low_speed_timeout_in_seconds,
+                    },
+                ) => {
+                    *provider = CompletionProvider::OpenAi(OpenAiCompletionProvider::new(
+                        model.clone(),
+                        api_url.clone(),
+                        client.http_client(),
+                        low_speed_timeout_in_seconds.map(Duration::from_secs),
+                        settings_version,
+                    ));
+                }
+                (
+                    _,
+                    AssistantProvider::Anthropic {
+                        model,
+                        api_url,
+                        low_speed_timeout_in_seconds,
+                    },
+                ) => {
+                    *provider = CompletionProvider::Anthropic(AnthropicCompletionProvider::new(
+                        model.clone(),
+                        api_url.clone(),
+                        client.http_client(),
+                        low_speed_timeout_in_seconds.map(Duration::from_secs),
+                        settings_version,
+                    ));
+                }
+                (
+                    _,
+                    AssistantProvider::Ollama {
+                        model,
+                        api_url,
+                        low_speed_timeout_in_seconds,
+                    },
+                ) => {
+                    *provider = CompletionProvider::Ollama(OllamaCompletionProvider::new(
+                        model.clone(),
+                        api_url.clone(),
+                        client.http_client(),
+                        low_speed_timeout_in_seconds.map(Duration::from_secs),
+                        settings_version,
+                        cx,
+                    ));
+                }
+            }
        })
    })
    .detach();
 }

-pub struct CompletionResponse {
-    pub inner: BoxFuture<'static, Result<BoxStream<'static, Result<String>>>>,
-    _lock: SemaphoreGuardArc,
-}
-
-pub trait LanguageModelCompletionProvider: Send + Sync {
-    fn available_models(&self, cx: &AppContext) -> Vec<LanguageModel>;
-    fn settings_version(&self) -> usize;
-    fn is_authenticated(&self) -> bool;
-    fn authenticate(&self, cx: &AppContext) -> Task<Result<()>>;
-    fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView;
-    fn reset_credentials(&self, cx: &AppContext) -> Task<Result<()>>;
-    fn model(&self) -> LanguageModel;
-    fn count_tokens(
-        &self,
-        request: LanguageModelRequest,
-        cx: &AppContext,
-    ) -> BoxFuture<'static, Result<usize>>;
-    fn complete(
-        &self,
-        request: LanguageModelRequest,
-    ) -> BoxFuture<'static, Result<BoxStream<'static, Result<String>>>>;
-
-    fn as_any_mut(&mut self) -> &mut dyn Any;
-}
-
-const MAX_CONCURRENT_COMPLETION_REQUESTS: usize = 4;
-
-pub struct CompletionProvider {
-    provider: Arc<RwLock<dyn LanguageModelCompletionProvider>>,
-    client: Option<Arc<Client>>,
-    request_limiter: Arc<Semaphore>,
-}
-
-impl CompletionProvider {
-    pub fn new(
-        provider: Arc<RwLock<dyn LanguageModelCompletionProvider>>,
-        client: Option<Arc<Client>>,
-    ) -> Self {
-        Self {
-            provider,
-            client,
-            request_limiter: Arc::new(Semaphore::new(MAX_CONCURRENT_COMPLETION_REQUESTS)),
-        }
-    }
-
-    pub fn available_models(&self, cx: &AppContext) -> Vec<LanguageModel> {
-        self.provider.read().available_models(cx)
-    }
-
-    pub fn settings_version(&self) -> usize {
-        self.provider.read().settings_version()
-    }
-
-    pub fn is_authenticated(&self) -> bool {
-        self.provider.read().is_authenticated()
-    }
-
-    pub fn authenticate(&self, cx: &AppContext) -> Task<Result<()>> {
-        self.provider.read().authenticate(cx)
-    }
-
-    pub fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView {
-        self.provider.read().authentication_prompt(cx)
-    }
-
-    pub fn reset_credentials(&self, cx: &AppContext) -> Task<Result<()>> {
-        self.provider.read().reset_credentials(cx)
-    }
-
-    pub fn model(&self) -> LanguageModel {
-        self.provider.read().model()
-    }
-
-    pub fn count_tokens(
-        &self,
-        request: LanguageModelRequest,
-        cx: &AppContext,
-    ) -> BoxFuture<'static, Result<usize>> {
-        self.provider.read().count_tokens(request, cx)
-    }
-
-    pub fn complete(
-        &self,
-        request: LanguageModelRequest,
-        cx: &AppContext,
-    ) -> Task<CompletionResponse> {
-        let rate_limiter = self.request_limiter.clone();
-        let provider = self.provider.clone();
-        cx.background_executor().spawn(async move {
-            let lock = rate_limiter.acquire_arc().await;
-            let response = provider.read().complete(request);
-            CompletionResponse {
-                inner: response,
-                _lock: lock,
-            }
-        })
-    }
+pub enum CompletionProvider {
+    OpenAi(OpenAiCompletionProvider),
+    Anthropic(AnthropicCompletionProvider),
+    Cloud(CloudCompletionProvider),
+    #[cfg(test)]
+    Fake(FakeCompletionProvider),
+    Ollama(OllamaCompletionProvider),
 }

 impl gpui::Global for CompletionProvider {}
@@ -161,213 +201,121 @@ impl CompletionProvider {
        cx.global::<Self>()
    }

-    pub fn update_current_as<R, T: LanguageModelCompletionProvider + 'static>(
-        &mut self,
-        update: impl FnOnce(&mut T) -> R,
-    ) -> Option<R> {
-        let mut provider = self.provider.write();
-        if let Some(provider) = provider.as_any_mut().downcast_mut::<T>() {
-            Some(update(provider))
-        } else {
-            None
+    pub fn available_models(&self) -> Vec<LanguageModel> {
+        match self {
+            CompletionProvider::OpenAi(provider) => provider
+                .available_models()
+                .map(LanguageModel::OpenAi)
+                .collect(),
+            CompletionProvider::Anthropic(provider) => provider
+                .available_models()
+                .map(LanguageModel::Anthropic)
+                .collect(),
+            CompletionProvider::Cloud(provider) => provider
+                .available_models()
+                .map(LanguageModel::Cloud)
+                .collect(),
+            CompletionProvider::Ollama(provider) => provider
+                .available_models()
+                .map(|model| LanguageModel::Ollama(model.clone()))
+                .collect(),
+            #[cfg(test)]
+            CompletionProvider::Fake(_) => unimplemented!(),
        }
    }

-    pub fn update_settings(&mut self, version: usize, cx: &mut AppContext) {
-        let updated = match &AssistantSettings::get_global(cx).provider {
-            AssistantProvider::ZedDotDev { model } => self
-                .update_current_as::<_, CloudCompletionProvider>(|provider| {
-                    provider.update(model.clone(), version);
-                }),
-            AssistantProvider::OpenAi {
-                model,
-                api_url,
-                low_speed_timeout_in_seconds,
-                available_models,
-            } => self.update_current_as::<_, OpenAiCompletionProvider>(|provider| {
-                provider.update(
-                    choose_openai_model(&model, &available_models),
-                    api_url.clone(),
-                    low_speed_timeout_in_seconds.map(Duration::from_secs),
-                    version,
-                );
-            }),
-            AssistantProvider::Anthropic {
-                model,
-                api_url,
-                low_speed_timeout_in_seconds,
-            } => self.update_current_as::<_, AnthropicCompletionProvider>(|provider| {
-                provider.update(
-                    model.clone(),
-                    api_url.clone(),
-                    low_speed_timeout_in_seconds.map(Duration::from_secs),
-                    version,
-                );
-            }),
-            AssistantProvider::Ollama {
-                model,
-                api_url,
-                low_speed_timeout_in_seconds,
-            } => self.update_current_as::<_, OllamaCompletionProvider>(|provider| {
-                provider.update(
-                    model.clone(),
-                    api_url.clone(),
-                    low_speed_timeout_in_seconds.map(Duration::from_secs),
-                    version,
-                    cx,
-                );
-            }),
-        };
+    pub fn settings_version(&self) -> usize {
+        match self {
+            CompletionProvider::OpenAi(provider) => provider.settings_version(),
+            CompletionProvider::Anthropic(provider) => provider.settings_version(),
+            CompletionProvider::Cloud(provider) => provider.settings_version(),
+            CompletionProvider::Ollama(provider) => provider.settings_version(),
+            #[cfg(test)]
+            CompletionProvider::Fake(_) => unimplemented!(),
+        }
+    }

-        // Previously configured provider was changed to another one
-        if updated.is_none() {
-            if let Some(client) = self.client.clone() {
-                self.provider = create_provider_from_settings(client, version, cx);
-            } else {
-                log::warn!("completion provider cannot be created because client is not set");
-            }
+    pub fn is_authenticated(&self) -> bool {
+        match self {
+            CompletionProvider::OpenAi(provider) => provider.is_authenticated(),
+            CompletionProvider::Anthropic(provider) => provider.is_authenticated(),
+            CompletionProvider::Cloud(provider) => provider.is_authenticated(),
+            CompletionProvider::Ollama(provider) => provider.is_authenticated(),
+            #[cfg(test)]
+            CompletionProvider::Fake(_) => true,
+        }
+    }
+
+    pub fn authenticate(&self, cx: &AppContext) -> Task<Result<()>> {
+        match self {
+            CompletionProvider::OpenAi(provider) => provider.authenticate(cx),
+            CompletionProvider::Anthropic(provider) => provider.authenticate(cx),
+            CompletionProvider::Cloud(provider) => provider.authenticate(cx),
+            CompletionProvider::Ollama(provider) => provider.authenticate(cx),
+            #[cfg(test)]
+            CompletionProvider::Fake(_) => Task::ready(Ok(())),
+        }
+    }
+
+    pub fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView {
+        match self {
+            CompletionProvider::OpenAi(provider) => provider.authentication_prompt(cx),
+            CompletionProvider::Anthropic(provider) => provider.authentication_prompt(cx),
+            CompletionProvider::Cloud(provider) => provider.authentication_prompt(cx),
+            CompletionProvider::Ollama(provider) => provider.authentication_prompt(cx),
+            #[cfg(test)]
+            CompletionProvider::Fake(_) => unimplemented!(),
+        }
+    }
+
+    pub fn reset_credentials(&self, cx: &AppContext) -> Task<Result<()>> {
+        match self {
+            CompletionProvider::OpenAi(provider) => provider.reset_credentials(cx),
+            CompletionProvider::Anthropic(provider) => provider.reset_credentials(cx),
+            CompletionProvider::Cloud(_) => Task::ready(Ok(())),
+            CompletionProvider::Ollama(provider) => provider.reset_credentials(cx),
+            #[cfg(test)]
+            CompletionProvider::Fake(_) => Task::ready(Ok(())),
+        }
+    }
+
+    pub fn model(&self) -> LanguageModel {
+        match self {
+            CompletionProvider::OpenAi(provider) => LanguageModel::OpenAi(provider.model()),
+            CompletionProvider::Anthropic(provider) => LanguageModel::Anthropic(provider.model()),
+            CompletionProvider::Cloud(provider) => LanguageModel::Cloud(provider.model()),
+            CompletionProvider::Ollama(provider) => LanguageModel::Ollama(provider.model()),
+            #[cfg(test)]
+            CompletionProvider::Fake(_) => LanguageModel::default(),
+        }
+    }
+
+    pub fn count_tokens(
+        &self,
+        request: LanguageModelRequest,
+        cx: &AppContext,
+    ) -> BoxFuture<'static, Result<usize>> {
+        match self {
+            CompletionProvider::OpenAi(provider) => provider.count_tokens(request, cx),
+            CompletionProvider::Anthropic(provider) => provider.count_tokens(request, cx),
+            CompletionProvider::Cloud(provider) => provider.count_tokens(request, cx),
+            CompletionProvider::Ollama(provider) => provider.count_tokens(request, cx),
+            #[cfg(test)]
+            CompletionProvider::Fake(_) => futures::FutureExt::boxed(futures::future::ready(Ok(0))),
+        }
+    }
+
+    pub fn complete(
+        &self,
+        request: LanguageModelRequest,
+    ) -> BoxFuture<'static, Result<BoxStream<'static, Result<String>>>> {
+        match self {
+            CompletionProvider::OpenAi(provider) => provider.complete(request),
+            CompletionProvider::Anthropic(provider) => provider.complete(request),
+            CompletionProvider::Cloud(provider) => provider.complete(request),
+            CompletionProvider::Ollama(provider) => provider.complete(request),
+            #[cfg(test)]
+            CompletionProvider::Fake(provider) => provider.complete(),
        }
    }
 }
-
-fn create_provider_from_settings(
-    client: Arc<Client>,
-    settings_version: usize,
-    cx: &mut AppContext,
-) -> Arc<RwLock<dyn LanguageModelCompletionProvider>> {
-    match &AssistantSettings::get_global(cx).provider {
-        AssistantProvider::ZedDotDev { model } => Arc::new(RwLock::new(
-            CloudCompletionProvider::new(model.clone(), client.clone(), settings_version, cx),
-        )),
-        AssistantProvider::OpenAi {
-            model,
-            api_url,
-            low_speed_timeout_in_seconds,
-            available_models,
-        } => Arc::new(RwLock::new(OpenAiCompletionProvider::new(
-            choose_openai_model(&model, &available_models),
-            api_url.clone(),
-            client.http_client(),
-            low_speed_timeout_in_seconds.map(Duration::from_secs),
-            settings_version,
-        ))),
-        AssistantProvider::Anthropic {
-            model,
-            api_url,
-            low_speed_timeout_in_seconds,
-        } => Arc::new(RwLock::new(AnthropicCompletionProvider::new(
-            model.clone(),
-            api_url.clone(),
-            client.http_client(),
-            low_speed_timeout_in_seconds.map(Duration::from_secs),
-            settings_version,
-        ))),
-        AssistantProvider::Ollama {
-            model,
-            api_url,
-            low_speed_timeout_in_seconds,
-        } => Arc::new(RwLock::new(OllamaCompletionProvider::new(
-            model.clone(),
-            api_url.clone(),
-            client.http_client(),
-            low_speed_timeout_in_seconds.map(Duration::from_secs),
-            settings_version,
-            cx,
-        ))),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::Arc;
-
-    use gpui::AppContext;
-    use parking_lot::RwLock;
-    use settings::SettingsStore;
-    use smol::stream::StreamExt;
-
-    use crate::{
-        completion_provider::MAX_CONCURRENT_COMPLETION_REQUESTS, CompletionProvider,
-        FakeCompletionProvider, LanguageModelRequest,
-    };
-
-    #[gpui::test]
-    fn test_rate_limiting(cx: &mut AppContext) {
-        SettingsStore::test(cx);
-        let fake_provider = FakeCompletionProvider::setup_test(cx);
-
-        let provider = CompletionProvider::new(Arc::new(RwLock::new(fake_provider.clone())), None);
-
-        // Enqueue some requests
-        for i in 0..MAX_CONCURRENT_COMPLETION_REQUESTS * 2 {
-            let response = provider.complete(
-                LanguageModelRequest {
-                    temperature: i as f32 / 10.0,
-                    ..Default::default()
-                },
-                cx,
-            );
-            cx.background_executor()
-                .spawn(async move {
-                    let response = response.await;
-                    let mut stream = response.inner.await.unwrap();
-                    while let Some(message) = stream.next().await {
-                        message.unwrap();
-                    }
-                })
-                .detach();
-        }
-        cx.background_executor().run_until_parked();
-
-        assert_eq!(
-            fake_provider.completion_count(),
-            MAX_CONCURRENT_COMPLETION_REQUESTS
-        );
-
-        // Get the first completion request that is in flight and mark it as completed.
-        let completion = fake_provider
-            .running_completions()
-            .into_iter()
-            .next()
-            .unwrap();
-        fake_provider.finish_completion(&completion);
-
-        // Ensure that the number of in-flight completion requests is reduced.
-        assert_eq!(
-            fake_provider.completion_count(),
-            MAX_CONCURRENT_COMPLETION_REQUESTS - 1
-        );
-
-        cx.background_executor().run_until_parked();
-
-        // Ensure that another completion request was allowed to acquire the lock.
-        assert_eq!(
-            fake_provider.completion_count(),
-            MAX_CONCURRENT_COMPLETION_REQUESTS
-        );
-
-        // Mark all completion requests as finished that are in flight.
-        for request in fake_provider.running_completions() {
-            fake_provider.finish_completion(&request);
-        }
-
-        assert_eq!(fake_provider.completion_count(), 0);
-
-        // Wait until the background tasks acquire the lock again.
-        cx.background_executor().run_until_parked();
-
-        assert_eq!(
-            fake_provider.completion_count(),
-            MAX_CONCURRENT_COMPLETION_REQUESTS - 1
-        );
-
-        // Finish all remaining completion requests.
-        for request in fake_provider.running_completions() {
-            fake_provider.finish_completion(&request);
-        }
-
-        cx.background_executor().run_until_parked();
-
-        assert_eq!(fake_provider.completion_count(), 0);
-    }
-}
--- a/crates/assistant/src/completion_provider/anthropic.rs
+++ b/crates/assistant/src/completion_provider/anthropic.rs
@@ -2,7 +2,7 @@ use crate::{
    assistant_settings::AnthropicModel, CompletionProvider, LanguageModel, LanguageModelRequest,
    Role,
 };
-use crate::{count_open_ai_tokens, LanguageModelCompletionProvider, LanguageModelRequestMessage};
+use crate::{count_open_ai_tokens, LanguageModelRequestMessage};
 use anthropic::{stream_completion, Request, RequestMessage};
 use anyhow::{anyhow, Result};
 use editor::{Editor, EditorElement, EditorStyle};
@@ -26,22 +26,50 @@ pub struct AnthropicCompletionProvider {
    settings_version: usize,
 }

-impl LanguageModelCompletionProvider for AnthropicCompletionProvider {
-    fn available_models(&self, _cx: &AppContext) -> Vec<LanguageModel> {
-        AnthropicModel::iter()
-            .map(LanguageModel::Anthropic)
-            .collect()
+impl AnthropicCompletionProvider {
+    pub fn new(
+        model: AnthropicModel,
+        api_url: String,
+        http_client: Arc<dyn HttpClient>,
+        low_speed_timeout: Option<Duration>,
+        settings_version: usize,
+    ) -> Self {
+        Self {
+            api_key: None,
+            api_url,
+            model,
+            http_client,
+            low_speed_timeout,
+            settings_version,
+        }
    }

-    fn settings_version(&self) -> usize {
+    pub fn update(
+        &mut self,
+        model: AnthropicModel,
+        api_url: String,
+        low_speed_timeout: Option<Duration>,
+        settings_version: usize,
+    ) {
+        self.model = model;
+        self.api_url = api_url;
+        self.low_speed_timeout = low_speed_timeout;
+        self.settings_version = settings_version;
+    }
+
+    pub fn available_models(&self) -> impl Iterator<Item = AnthropicModel> {
+        AnthropicModel::iter()
+    }
+
+    pub fn settings_version(&self) -> usize {
        self.settings_version
    }

-    fn is_authenticated(&self) -> bool {
+    pub fn is_authenticated(&self) -> bool {
        self.api_key.is_some()
    }

-    fn authenticate(&self, cx: &AppContext) -> Task<Result<()>> {
+    pub fn authenticate(&self, cx: &AppContext) -> Task<Result<()>> {
        if self.is_authenticated() {
            Task::ready(Ok(()))
        } else {
@@ -57,36 +85,36 @@ impl LanguageModelCompletionProvider for AnthropicCompletionProvider {
                    String::from_utf8(api_key)?
                };
                cx.update_global::<CompletionProvider, _>(|provider, _cx| {
-                    provider.update_current_as::<_, AnthropicCompletionProvider>(|provider| {
+                    if let CompletionProvider::Anthropic(provider) = provider {
                        provider.api_key = Some(api_key);
-                    });
+                    }
                })
            })
        }
    }

-    fn reset_credentials(&self, cx: &AppContext) -> Task<Result<()>> {
+    pub fn reset_credentials(&self, cx: &AppContext) -> Task<Result<()>> {
        let delete_credentials = cx.delete_credentials(&self.api_url);
        cx.spawn(|mut cx| async move {
            delete_credentials.await.log_err();
            cx.update_global::<CompletionProvider, _>(|provider, _cx| {
-                provider.update_current_as::<_, AnthropicCompletionProvider>(|provider| {
+                if let CompletionProvider::Anthropic(provider) = provider {
                    provider.api_key = None;
-                });
+                }
            })
        })
    }

-    fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView {
+    pub fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView {
        cx.new_view(|cx| AuthenticationPrompt::new(self.api_url.clone(), cx))
            .into()
    }

-    fn model(&self) -> LanguageModel {
-        LanguageModel::Anthropic(self.model.clone())
+    pub fn model(&self) -> AnthropicModel {
+        self.model.clone()
    }

-    fn count_tokens(
+    pub fn count_tokens(
        &self,
        request: LanguageModelRequest,
        cx: &AppContext,
@@ -94,7 +122,7 @@ impl LanguageModelCompletionProvider for AnthropicCompletionProvider {
        count_open_ai_tokens(request, cx.background_executor())
    }

-    fn complete(
+    pub fn complete(
        &self,
        request: LanguageModelRequest,
    ) -> BoxFuture<'static, Result<BoxStream<'static, Result<String>>>> {
@@ -139,48 +167,12 @@ impl LanguageModelCompletionProvider for AnthropicCompletionProvider {
        .boxed()
    }

-    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
-        self
-    }
-}
-
-impl AnthropicCompletionProvider {
-    pub fn new(
-        model: AnthropicModel,
-        api_url: String,
-        http_client: Arc<dyn HttpClient>,
-        low_speed_timeout: Option<Duration>,
-        settings_version: usize,
-    ) -> Self {
-        Self {
-            api_key: None,
-            api_url,
-            model,
-            http_client,
-            low_speed_timeout,
-            settings_version,
-        }
-    }
-
-    pub fn update(
-        &mut self,
-        model: AnthropicModel,
-        api_url: String,
-        low_speed_timeout: Option<Duration>,
-        settings_version: usize,
-    ) {
-        self.model = model;
-        self.api_url = api_url;
-        self.low_speed_timeout = low_speed_timeout;
-        self.settings_version = settings_version;
-    }
-
    fn to_anthropic_request(&self, mut request: LanguageModelRequest) -> Request {
        preprocess_anthropic_request(&mut request);

        let model = match request.model {
            LanguageModel::Anthropic(model) => model,
-            _ => self.model.clone(),
+            _ => self.model(),
        };

        let mut system_message = String::new();
@@ -244,7 +236,7 @@ pub fn preprocess_anthropic_request(request: &mut LanguageModelRequest) {
    }

    if !system_message.is_empty() {
-        new_messages.insert(
+        request.messages.insert(
            0,
            LanguageModelRequestMessage {
                role: Role::System,
@@ -286,9 +278,9 @@ impl AuthenticationPrompt {
        cx.spawn(|_, mut cx| async move {
            write_credentials.await?;
            cx.update_global::<CompletionProvider, _>(|provider, _cx| {
-                provider.update_current_as::<_, AnthropicCompletionProvider>(|provider| {
+                if let CompletionProvider::Anthropic(provider) = provider {
                    provider.api_key = Some(api_key);
-                });
+                }
            })
        })
        .detach_and_log_err(cx);
--- a/crates/assistant/src/completion_provider/cloud.rs
+++ b/crates/assistant/src/completion_provider/cloud.rs
@@ -1,6 +1,6 @@
 use crate::{
    assistant_settings::CloudModel, count_open_ai_tokens, CompletionProvider, LanguageModel,
-    LanguageModelCompletionProvider, LanguageModelRequest,
+    LanguageModelRequest,
 };
 use anyhow::{anyhow, Result};
 use client::{proto, Client};
@@ -30,9 +30,11 @@ impl CloudCompletionProvider {
        let maintain_client_status = cx.spawn(|mut cx| async move {
            while let Some(status) = status_rx.next().await {
                let _ = cx.update_global::<CompletionProvider, _>(|provider, _cx| {
-                    provider.update_current_as::<_, Self>(|provider| {
+                    if let CompletionProvider::Cloud(provider) = provider {
                        provider.status = status;
-                    });
+                    } else {
+                        unreachable!()
+                    }
                });
            }
        });
@@ -49,53 +51,44 @@ impl CloudCompletionProvider {
        self.model = model;
        self.settings_version = settings_version;
    }
-}

-impl LanguageModelCompletionProvider for CloudCompletionProvider {
-    fn available_models(&self, _cx: &AppContext) -> Vec<LanguageModel> {
+    pub fn available_models(&self) -> impl Iterator<Item = CloudModel> {
        let mut custom_model = if let CloudModel::Custom(custom_model) = self.model.clone() {
            Some(custom_model)
        } else {
            None
        };
-        CloudModel::iter()
-            .filter_map(move |model| {
-                if let CloudModel::Custom(_) = model {
-                    Some(CloudModel::Custom(custom_model.take()?))
-                } else {
-                    Some(model)
-                }
-            })
-            .map(LanguageModel::Cloud)
-            .collect()
+        CloudModel::iter().filter_map(move |model| {
+            if let CloudModel::Custom(_) = model {
+                Some(CloudModel::Custom(custom_model.take()?))
+            } else {
+                Some(model)
+            }
+        })
    }

-    fn settings_version(&self) -> usize {
+    pub fn settings_version(&self) -> usize {
        self.settings_version
    }

-    fn is_authenticated(&self) -> bool {
+    pub fn model(&self) -> CloudModel {
+        self.model.clone()
+    }
+
+    pub fn is_authenticated(&self) -> bool {
        self.status.is_connected()
    }

-    fn authenticate(&self, cx: &AppContext) -> Task<Result<()>> {
+    pub fn authenticate(&self, cx: &AppContext) -> Task<Result<()>> {
        let client = self.client.clone();
        cx.spawn(move |cx| async move { client.authenticate_and_connect(true, &cx).await })
    }

-    fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView {
+    pub fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView {
        cx.new_view(|_cx| AuthenticationPrompt).into()
    }

-    fn reset_credentials(&self, _cx: &AppContext) -> Task<Result<()>> {
-        Task::ready(Ok(()))
-    }
-
-    fn model(&self) -> LanguageModel {
-        LanguageModel::Cloud(self.model.clone())
-    }
-
-    fn count_tokens(
+    pub fn count_tokens(
        &self,
        request: LanguageModelRequest,
        cx: &AppContext,
@@ -135,7 +128,7 @@ impl LanguageModelCompletionProvider for CloudCompletionProvider {
        }
    }

-    fn complete(
+    pub fn complete(
        &self,
        mut request: LanguageModelRequest,
    ) -> BoxFuture<'static, Result<BoxStream<'static, Result<String>>>> {
@@ -168,10 +161,6 @@ impl LanguageModelCompletionProvider for CloudCompletionProvider {
            })
            .boxed()
    }
-
-    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
-        self
-    }
 }

 struct AuthenticationPrompt;
--- a/crates/assistant/src/completion_provider/fake.rs
+++ b/crates/assistant/src/completion_provider/fake.rs
@@ -1,107 +1,29 @@
 use anyhow::Result;
-use collections::HashMap;
 use futures::{channel::mpsc, future::BoxFuture, stream::BoxStream, FutureExt, StreamExt};
-use gpui::{AnyView, AppContext, Task};
 use std::sync::Arc;
-use ui::WindowContext;
-
-use crate::{LanguageModel, LanguageModelCompletionProvider, LanguageModelRequest};

 #[derive(Clone, Default)]
 pub struct FakeCompletionProvider {
-    current_completion_txs: Arc<parking_lot::Mutex<HashMap<String, mpsc::UnboundedSender<String>>>>,
+    current_completion_tx: Arc<parking_lot::Mutex<Option<mpsc::UnboundedSender<String>>>>,
 }

 impl FakeCompletionProvider {
-    #[cfg(test)]
-    pub fn setup_test(cx: &mut AppContext) -> Self {
-        use crate::CompletionProvider;
-        use parking_lot::RwLock;
-
-        let this = Self::default();
-        let provider = CompletionProvider::new(Arc::new(RwLock::new(this.clone())), None);
-        cx.set_global(provider);
-        this
+    pub fn complete(&self) -> BoxFuture<'static, Result<BoxStream<'static, Result<String>>>> {
+        let (tx, rx) = mpsc::unbounded();
+        *self.current_completion_tx.lock() = Some(tx);
+        async move { Ok(rx.map(Ok).boxed()) }.boxed()
    }

-    pub fn running_completions(&self) -> Vec<LanguageModelRequest> {
-        self.current_completion_txs
+    pub fn send_completion(&self, chunk: String) {
+        self.current_completion_tx
            .lock()
-            .keys()
-            .map(|k| serde_json::from_str(k).unwrap())
-            .collect()
-    }
-
-    pub fn completion_count(&self) -> usize {
-        self.current_completion_txs.lock().len()
-    }
-
-    pub fn send_completion(&self, request: &LanguageModelRequest, chunk: String) {
-        let json = serde_json::to_string(request).unwrap();
-        self.current_completion_txs
-            .lock()
-            .get(&json)
+            .as_ref()
            .unwrap()
            .unbounded_send(chunk)
            .unwrap();
    }

-    pub fn finish_completion(&self, request: &LanguageModelRequest) {
-        self.current_completion_txs
-            .lock()
-            .remove(&serde_json::to_string(request).unwrap());
-    }
-}
-
-impl LanguageModelCompletionProvider for FakeCompletionProvider {
-    fn available_models(&self, _cx: &AppContext) -> Vec<LanguageModel> {
-        vec![LanguageModel::default()]
-    }
-
-    fn settings_version(&self) -> usize {
-        0
-    }
-
-    fn is_authenticated(&self) -> bool {
-        true
-    }
-
-    fn authenticate(&self, _cx: &AppContext) -> Task<Result<()>> {
-        Task::ready(Ok(()))
-    }
-
-    fn authentication_prompt(&self, _cx: &mut WindowContext) -> AnyView {
-        unimplemented!()
-    }
-
-    fn reset_credentials(&self, _cx: &AppContext) -> Task<Result<()>> {
-        Task::ready(Ok(()))
-    }
-
-    fn model(&self) -> LanguageModel {
-        LanguageModel::default()
-    }
-
-    fn count_tokens(
-        &self,
-        _request: LanguageModelRequest,
-        _cx: &AppContext,
-    ) -> BoxFuture<'static, Result<usize>> {
-        futures::future::ready(Ok(0)).boxed()
-    }
-
-    fn complete(
-        &self,
-        _request: LanguageModelRequest,
-    ) -> BoxFuture<'static, Result<BoxStream<'static, Result<String>>>> {
-        let (tx, rx) = mpsc::unbounded();
-        self.current_completion_txs
-            .lock()
-            .insert(serde_json::to_string(&_request).unwrap(), tx);
-        async move { Ok(rx.map(Ok).boxed()) }.boxed()
-    }
-
-    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
-        self
+    pub fn finish_completion(&self) {
+        self.current_completion_tx.lock().take();
    }
 }
--- a/crates/assistant/src/completion_provider/ollama.rs
+++ b/crates/assistant/src/completion_provider/ollama.rs
@@ -1,4 +1,3 @@
-use crate::LanguageModelCompletionProvider;
 use crate::{
    assistant_settings::OllamaModel, CompletionProvider, LanguageModel, LanguageModelRequest, Role,
 };
@@ -27,108 +26,6 @@ pub struct OllamaCompletionProvider {
    available_models: Vec<OllamaModel>,
 }

-impl LanguageModelCompletionProvider for OllamaCompletionProvider {
-    fn available_models(&self, _cx: &AppContext) -> Vec<LanguageModel> {
-        self.available_models
-            .iter()
-            .map(|m| LanguageModel::Ollama(m.clone()))
-            .collect()
-    }
-
-    fn settings_version(&self) -> usize {
-        self.settings_version
-    }
-
-    fn is_authenticated(&self) -> bool {
-        !self.available_models.is_empty()
-    }
-
-    fn authenticate(&self, cx: &AppContext) -> Task<Result<()>> {
-        if self.is_authenticated() {
-            Task::ready(Ok(()))
-        } else {
-            self.fetch_models(cx)
-        }
-    }
-
-    fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView {
-        let fetch_models = Box::new(move |cx: &mut WindowContext| {
-            cx.update_global::<CompletionProvider, _>(|provider, cx| {
-                provider
-                    .update_current_as::<_, OllamaCompletionProvider>(|provider| {
-                        provider.fetch_models(cx)
-                    })
-                    .unwrap_or_else(|| Task::ready(Ok(())))
-            })
-        });
-
-        cx.new_view(|cx| DownloadOllamaMessage::new(fetch_models, cx))
-            .into()
-    }
-
-    fn reset_credentials(&self, cx: &AppContext) -> Task<Result<()>> {
-        self.fetch_models(cx)
-    }
-
-    fn model(&self) -> LanguageModel {
-        LanguageModel::Ollama(self.model.clone())
-    }
-
-    fn count_tokens(
-        &self,
-        request: LanguageModelRequest,
-        _cx: &AppContext,
-    ) -> BoxFuture<'static, Result<usize>> {
-        // There is no endpoint for this _yet_ in Ollama
-        // see: https://github.com/ollama/ollama/issues/1716 and https://github.com/ollama/ollama/issues/3582
-        let token_count = request
-            .messages
-            .iter()
-            .map(|msg| msg.content.chars().count())
-            .sum::<usize>()
-            / 4;
-
-        async move { Ok(token_count) }.boxed()
-    }
-
-    fn complete(
-        &self,
-        request: LanguageModelRequest,
-    ) -> BoxFuture<'static, Result<BoxStream<'static, Result<String>>>> {
-        let request = self.to_ollama_request(request);
-
-        let http_client = self.http_client.clone();
-        let api_url = self.api_url.clone();
-        let low_speed_timeout = self.low_speed_timeout;
-        async move {
-            let request =
-                stream_chat_completion(http_client.as_ref(), &api_url, request, low_speed_timeout);
-            let response = request.await?;
-            let stream = response
-                .filter_map(|response| async move {
-                    match response {
-                        Ok(delta) => {
-                            let content = match delta.message {
-                                ChatMessage::User { content } => content,
-                                ChatMessage::Assistant { content } => content,
-                                ChatMessage::System { content } => content,
-                            };
-                            Some(Ok(content))
-                        }
-                        Err(error) => Some(Err(error)),
-                    }
-                })
-                .boxed();
-            Ok(stream)
-        }
-        .boxed()
-    }
-
-    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
-        self
-    }
-}
-
 impl OllamaCompletionProvider {
    pub fn new(
        model: OllamaModel,
@@ -190,12 +87,36 @@ impl OllamaCompletionProvider {
        self.settings_version = settings_version;
    }

+    pub fn available_models(&self) -> impl Iterator<Item = &OllamaModel> {
+        self.available_models.iter()
+    }
+
    pub fn select_first_available_model(&mut self) {
        if let Some(model) = self.available_models.first() {
            self.model = model.clone();
        }
    }

+    pub fn settings_version(&self) -> usize {
+        self.settings_version
+    }
+
+    pub fn is_authenticated(&self) -> bool {
+        !self.available_models.is_empty()
+    }
+
+    pub fn authenticate(&self, cx: &AppContext) -> Task<Result<()>> {
+        if self.is_authenticated() {
+            Task::ready(Ok(()))
+        } else {
+            self.fetch_models(cx)
+        }
+    }
+
+    pub fn reset_credentials(&self, cx: &AppContext) -> Task<Result<()>> {
+        self.fetch_models(cx)
+    }
+
    pub fn fetch_models(&self, cx: &AppContext) -> Task<Result<()>> {
        let http_client = self.http_client.clone();
        let api_url = self.api_url.clone();
@@ -216,21 +137,90 @@ impl OllamaCompletionProvider {
            models.sort_by(|a, b| a.name.cmp(&b.name));

            cx.update_global::<CompletionProvider, _>(|provider, _cx| {
-                provider.update_current_as::<_, OllamaCompletionProvider>(|provider| {
+                if let CompletionProvider::Ollama(provider) = provider {
                    provider.available_models = models;

                    if !provider.available_models.is_empty() && provider.model.name.is_empty() {
                        provider.select_first_available_model()
                    }
-                });
+                }
            })
        })
    }

+    pub fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView {
+        let fetch_models = Box::new(move |cx: &mut WindowContext| {
+            cx.update_global::<CompletionProvider, _>(|provider, cx| {
+                if let CompletionProvider::Ollama(provider) = provider {
+                    provider.fetch_models(cx)
+                } else {
+                    Task::ready(Ok(()))
+                }
+            })
+        });
+
+        cx.new_view(|cx| DownloadOllamaMessage::new(fetch_models, cx))
+            .into()
+    }
+
+    pub fn model(&self) -> OllamaModel {
+        self.model.clone()
+    }
+
+    pub fn count_tokens(
+        &self,
+        request: LanguageModelRequest,
+        _cx: &AppContext,
+    ) -> BoxFuture<'static, Result<usize>> {
+        // There is no endpoint for this _yet_ in Ollama
+        // see: https://github.com/ollama/ollama/issues/1716 and https://github.com/ollama/ollama/issues/3582
+        let token_count = request
+            .messages
+            .iter()
+            .map(|msg| msg.content.chars().count())
+            .sum::<usize>()
+            / 4;
+
+        async move { Ok(token_count) }.boxed()
+    }
+
+    pub fn complete(
+        &self,
+        request: LanguageModelRequest,
+    ) -> BoxFuture<'static, Result<BoxStream<'static, Result<String>>>> {
+        let request = self.to_ollama_request(request);
+
+        let http_client = self.http_client.clone();
+        let api_url = self.api_url.clone();
+        let low_speed_timeout = self.low_speed_timeout;
+        async move {
+            let request =
+                stream_chat_completion(http_client.as_ref(), &api_url, request, low_speed_timeout);
+            let response = request.await?;
+            let stream = response
+                .filter_map(|response| async move {
+                    match response {
+                        Ok(delta) => {
+                            let content = match delta.message {
+                                ChatMessage::User { content } => content,
+                                ChatMessage::Assistant { content } => content,
+                                ChatMessage::System { content } => content,
+                            };
+                            Some(Ok(content))
+                        }
+                        Err(error) => Some(Err(error)),
+                    }
+                })
+                .boxed();
+            Ok(stream)
+        }
+        .boxed()
+    }
+
    fn to_ollama_request(&self, request: LanguageModelRequest) -> ChatRequest {
        let model = match request.model {
            LanguageModel::Ollama(model) => model,
-            _ => self.model.clone(),
+            _ => self.model(),
        };

        ChatRequest {
--- a/crates/assistant/src/completion_provider/open_ai.rs
+++ b/crates/assistant/src/completion_provider/open_ai.rs
@@ -1,6 +1,4 @@
 use crate::assistant_settings::CloudModel;
-use crate::assistant_settings::{AssistantProvider, AssistantSettings};
-use crate::LanguageModelCompletionProvider;
 use crate::{
    assistant_settings::OpenAiModel, CompletionProvider, LanguageModel, LanguageModelRequest, Role,
 };
@@ -58,75 +56,19 @@ impl OpenAiCompletionProvider {
        self.settings_version = settings_version;
    }

-    fn to_open_ai_request(&self, request: LanguageModelRequest) -> Request {
-        let model = match request.model {
-            LanguageModel::OpenAi(model) => model,
-            _ => self.model.clone(),
-        };
-
-        Request {
-            model,
-            messages: request
-                .messages
-                .into_iter()
-                .map(|msg| match msg.role {
-                    Role::User => RequestMessage::User {
-                        content: msg.content,
-                    },
-                    Role::Assistant => RequestMessage::Assistant {
-                        content: Some(msg.content),
-                        tool_calls: Vec::new(),
-                    },
-                    Role::System => RequestMessage::System {
-                        content: msg.content,
-                    },
-                })
-                .collect(),
-            stream: true,
-            stop: request.stop,
-            temperature: request.temperature,
-            tools: Vec::new(),
-            tool_choice: None,
-        }
-    }
-}
-
-impl LanguageModelCompletionProvider for OpenAiCompletionProvider {
-    fn available_models(&self, cx: &AppContext) -> Vec<LanguageModel> {
-        if let AssistantProvider::OpenAi {
-            available_models, ..
-        } = &AssistantSettings::get_global(cx).provider
-        {
-            if !available_models.is_empty() {
-                return available_models
-                    .iter()
-                    .cloned()
-                    .map(LanguageModel::OpenAi)
-                    .collect();
-            }
-        }
-        let available_models = if matches!(self.model, OpenAiModel::Custom { .. }) {
-            vec![self.model.clone()]
-        } else {
-            OpenAiModel::iter()
-                .filter(|model| !matches!(model, OpenAiModel::Custom { .. }))
-                .collect()
-        };
-        available_models
-            .into_iter()
-            .map(LanguageModel::OpenAi)
-            .collect()
+    pub fn available_models(&self) -> impl Iterator<Item = OpenAiModel> {
+        OpenAiModel::iter()
    }

-    fn settings_version(&self) -> usize {
+    pub fn settings_version(&self) -> usize {
        self.settings_version
    }

-    fn is_authenticated(&self) -> bool {
+    pub fn is_authenticated(&self) -> bool {
        self.api_key.is_some()
    }

-    fn authenticate(&self, cx: &AppContext) -> Task<Result<()>> {
+    pub fn authenticate(&self, cx: &AppContext) -> Task<Result<()>> {
        if self.is_authenticated() {
            Task::ready(Ok(()))
        } else {
@@ -142,36 +84,36 @@ impl LanguageModelCompletionProvider for OpenAiCompletionProvider {
                    String::from_utf8(api_key)?
                };
                cx.update_global::<CompletionProvider, _>(|provider, _cx| {
-                    provider.update_current_as::<_, Self>(|provider| {
+                    if let CompletionProvider::OpenAi(provider) = provider {
                        provider.api_key = Some(api_key);
-                    });
+                    }
                })
            })
        }
    }

-    fn reset_credentials(&self, cx: &AppContext) -> Task<Result<()>> {
+    pub fn reset_credentials(&self, cx: &AppContext) -> Task<Result<()>> {
        let delete_credentials = cx.delete_credentials(&self.api_url);
        cx.spawn(|mut cx| async move {
            delete_credentials.await.log_err();
            cx.update_global::<CompletionProvider, _>(|provider, _cx| {
-                provider.update_current_as::<_, Self>(|provider| {
+                if let CompletionProvider::OpenAi(provider) = provider {
                    provider.api_key = None;
-                });
+                }
            })
        })
    }

-    fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView {
+    pub fn authentication_prompt(&self, cx: &mut WindowContext) -> AnyView {
        cx.new_view(|cx| AuthenticationPrompt::new(self.api_url.clone(), cx))
            .into()
    }

-    fn model(&self) -> LanguageModel {
-        LanguageModel::OpenAi(self.model.clone())
+    pub fn model(&self) -> OpenAiModel {
+        self.model.clone()
    }

-    fn count_tokens(
+    pub fn count_tokens(
        &self,
        request: LanguageModelRequest,
        cx: &AppContext,
@@ -179,7 +121,7 @@ impl LanguageModelCompletionProvider for OpenAiCompletionProvider {
        count_open_ai_tokens(request, cx.background_executor())
    }

-    fn complete(
+    pub fn complete(
        &self,
        request: LanguageModelRequest,
    ) -> BoxFuture<'static, Result<BoxStream<'static, Result<String>>>> {
@@ -212,8 +154,36 @@ impl LanguageModelCompletionProvider for OpenAiCompletionProvider {
        .boxed()
    }

-    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
-        self
+    fn to_open_ai_request(&self, request: LanguageModelRequest) -> Request {
+        let model = match request.model {
+            LanguageModel::OpenAi(model) => model,
+            _ => self.model(),
+        };
+
+        Request {
+            model,
+            messages: request
+                .messages
+                .into_iter()
+                .map(|msg| match msg.role {
+                    Role::User => RequestMessage::User {
+                        content: msg.content,
+                    },
+                    Role::Assistant => RequestMessage::Assistant {
+                        content: Some(msg.content),
+                        tool_calls: Vec::new(),
+                    },
+                    Role::System => RequestMessage::System {
+                        content: msg.content,
+                    },
+                })
+                .collect(),
+            stream: true,
+            stop: request.stop,
+            temperature: request.temperature,
+            tools: Vec::new(),
+            tool_choice: None,
+        }
    }
 }

@@ -243,8 +213,7 @@ pub fn count_open_ai_tokens(
                | LanguageModel::Cloud(CloudModel::Claude3_5Sonnet)
                | LanguageModel::Cloud(CloudModel::Claude3Opus)
                | LanguageModel::Cloud(CloudModel::Claude3Sonnet)
-                | LanguageModel::Cloud(CloudModel::Claude3Haiku)
-                | LanguageModel::OpenAi(OpenAiModel::Custom { .. }) => {
+                | LanguageModel::Cloud(CloudModel::Claude3Haiku) => {
                    // Tiktoken doesn't yet support these models, so we manually use the
                    // same tokenizer as GPT-4.
                    tiktoken_rs::num_tokens_from_messages("gpt-4", &messages)
@@ -295,9 +264,9 @@ impl AuthenticationPrompt {
        cx.spawn(|_, mut cx| async move {
            write_credentials.await?;
            cx.update_global::<CompletionProvider, _>(|provider, _cx| {
-                provider.update_current_as::<_, OpenAiCompletionProvider>(|provider| {
+                if let CompletionProvider::OpenAi(provider) = provider {
                    provider.api_key = Some(api_key);
-                });
+                }
            })
        })
        .detach_and_log_err(cx);
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -1,9 +1,8 @@
 use crate::{
-    assistant_settings::AssistantSettings, humanize_token_count, prompts::generate_content_prompt,
-    AssistantPanel, AssistantPanelEvent, CompletionProvider, Hunk, LanguageModelRequest,
-    LanguageModelRequestMessage, Role, StreamingDiff,
+    prompts::generate_content_prompt, AssistantPanel, CompletionProvider, Hunk,
+    LanguageModelRequest, LanguageModelRequestMessage, Role, StreamingDiff,
 };
-use anyhow::{anyhow, Context as _, Result};
+use anyhow::{Context as _, Result};
 use client::telemetry::Telemetry;
 use collections::{hash_map, HashMap, HashSet, VecDeque};
 use editor::{
@@ -15,18 +14,17 @@ use editor::{
    Anchor, AnchorRangeExt, Editor, EditorElement, EditorEvent, EditorMode, EditorStyle,
    ExcerptRange, GutterDimensions, MultiBuffer, MultiBufferSnapshot, ToOffset, ToPoint,
 };
-use fs::Fs;
 use futures::{channel::mpsc, SinkExt, Stream, StreamExt};
 use gpui::{
-    point, AppContext, EventEmitter, FocusHandle, FocusableView, FontStyle, Global, HighlightStyle,
-    Model, ModelContext, Subscription, Task, TextStyle, UpdateGlobal, View, ViewContext, WeakView,
-    WhiteSpace, WindowContext,
+    point, AppContext, EventEmitter, FocusHandle, FocusableView, FontStyle, FontWeight, Global,
+    HighlightStyle, Model, ModelContext, Subscription, Task, TextStyle, UpdateGlobal, View,
+    ViewContext, WeakView, WhiteSpace, WindowContext,
 };
 use language::{Buffer, Point, Selection, TransactionId};
 use multi_buffer::MultiBufferRow;
 use parking_lot::Mutex;
 use rope::Rope;
-use settings::{update_settings_file, Settings};
+use settings::Settings;
 use similar::TextDiff;
 use std::{
    cmp, mem,
@@ -34,15 +32,15 @@ use std::{
    pin::Pin,
    sync::Arc,
    task::{self, Poll},
-    time::{Duration, Instant},
+    time::Instant,
 };
 use theme::ThemeSettings;
-use ui::{prelude::*, ContextMenu, PopoverMenu, Tooltip};
+use ui::{prelude::*, Tooltip};
 use util::RangeExt;
 use workspace::{notifications::NotificationId, Toast, Workspace};

-pub fn init(fs: Arc<dyn Fs>, telemetry: Arc<Telemetry>, cx: &mut AppContext) {
-    cx.set_global(InlineAssistant::new(fs, telemetry));
+pub fn init(telemetry: Arc<Telemetry>, cx: &mut AppContext) {
+    cx.set_global(InlineAssistant::new(telemetry));
 }

 const PROMPT_HISTORY_MAX_LEN: usize = 20;
@@ -55,13 +53,12 @@ pub struct InlineAssistant {
    assist_groups: HashMap<InlineAssistGroupId, InlineAssistGroup>,
    prompt_history: VecDeque<String>,
    telemetry: Option<Arc<Telemetry>>,
-    fs: Arc<dyn Fs>,
 }

 impl Global for InlineAssistant {}

 impl InlineAssistant {
-    pub fn new(fs: Arc<dyn Fs>, telemetry: Arc<Telemetry>) -> Self {
+    pub fn new(telemetry: Arc<Telemetry>) -> Self {
        Self {
            next_assist_id: InlineAssistId::default(),
            next_assist_group_id: InlineAssistGroupId::default(),
@@ -70,7 +67,6 @@ impl InlineAssistant {
            assist_groups: HashMap::default(),
            prompt_history: VecDeque::default(),
            telemetry: Some(telemetry),
-            fs,
        }
    }

@@ -78,7 +74,7 @@ impl InlineAssistant {
        &mut self,
        editor: &View<Editor>,
        workspace: Option<WeakView<Workspace>>,
-        assistant_panel: Option<&View<AssistantPanel>>,
+        include_context: bool,
        cx: &mut WindowContext,
    ) {
        let snapshot = editor.read(cx).buffer().read(cx).snapshot(cx);
@@ -155,10 +151,7 @@ impl InlineAssistant {
                    self.prompt_history.clone(),
                    prompt_buffer.clone(),
                    codegen.clone(),
-                    editor,
-                    assistant_panel,
                    workspace.clone(),
-                    self.fs.clone(),
                    cx,
                )
            });
@@ -215,7 +208,7 @@ impl InlineAssistant {
                InlineAssist::new(
                    assist_id,
                    assist_group_id,
-                    assistant_panel.is_some(),
+                    include_context,
                    editor,
                    &prompt_editor,
                    block_ids[0],
@@ -713,6 +706,8 @@ impl InlineAssistant {
            return;
        }

+        assist.codegen.update(cx, |codegen, cx| codegen.undo(cx));
+
        let Some(user_prompt) = assist
            .decorations
            .as_ref()
@@ -721,138 +716,115 @@ impl InlineAssistant {
            return;
        };

+        let context = if assist.include_context {
+            assist.workspace.as_ref().and_then(|workspace| {
+                let workspace = workspace.upgrade()?.read(cx);
+                let assistant_panel = workspace.panel::<AssistantPanel>(cx)?;
+                assistant_panel.read(cx).active_context(cx)
+            })
+        } else {
+            None
+        };
+
+        let editor = if let Some(editor) = assist.editor.upgrade() {
+            editor
+        } else {
+            return;
+        };
+
+        let project_name = assist.workspace.as_ref().and_then(|workspace| {
+            let workspace = workspace.upgrade()?;
+            Some(
+                workspace
+                    .read(cx)
+                    .project()
+                    .read(cx)
+                    .worktree_root_names(cx)
+                    .collect::<Vec<&str>>()
+                    .join("/"),
+            )
+        });
+
        self.prompt_history.retain(|prompt| *prompt != user_prompt);
        self.prompt_history.push_back(user_prompt.clone());
        if self.prompt_history.len() > PROMPT_HISTORY_MAX_LEN {
            self.prompt_history.pop_front();
        }

-        assist.codegen.update(cx, |codegen, cx| codegen.undo(cx));
        let codegen = assist.codegen.clone();
-        let request = self.request_for_inline_assist(assist_id, cx);
-
-        cx.spawn(|mut cx| async move {
-            let request = request.await?;
-            codegen.update(&mut cx, |codegen, cx| codegen.start(request, cx))?;
-            anyhow::Ok(())
-        })
-        .detach_and_log_err(cx);
-    }
-
-    fn request_for_inline_assist(
-        &self,
-        assist_id: InlineAssistId,
-        cx: &mut WindowContext,
-    ) -> Task<Result<LanguageModelRequest>> {
-        cx.spawn(|mut cx| async move {
-            let (user_prompt, context_request, project_name, buffer, range, model) = cx
-                .read_global(|this: &InlineAssistant, cx: &WindowContext| {
-                    let assist = this.assists.get(&assist_id).context("invalid assist")?;
-                    let decorations = assist.decorations.as_ref().context("invalid assist")?;
-                    let editor = assist.editor.upgrade().context("invalid assist")?;
-                    let user_prompt = decorations.prompt_editor.read(cx).prompt(cx);
-                    let context_request = if assist.include_context {
-                        assist.workspace.as_ref().and_then(|workspace| {
-                            let workspace = workspace.upgrade()?.read(cx);
-                            let assistant_panel = workspace.panel::<AssistantPanel>(cx)?;
-                            Some(
-                                assistant_panel
-                                    .read(cx)
-                                    .active_context(cx)?
-                                    .read(cx)
-                                    .to_completion_request(cx),
-                            )
-                        })
-                    } else {
-                        None
-                    };
-                    let project_name = assist.workspace.as_ref().and_then(|workspace| {
-                        let workspace = workspace.upgrade()?;
-                        Some(
-                            workspace
-                                .read(cx)
-                                .project()
-                                .read(cx)
-                                .worktree_root_names(cx)
-                                .collect::<Vec<&str>>()
-                                .join("/"),
-                        )
-                    });
-                    let buffer = editor.read(cx).buffer().read(cx).snapshot(cx);
-                    let range = assist.codegen.read(cx).range.clone();
-                    let model = CompletionProvider::global(cx).model();
-                    anyhow::Ok((
-                        user_prompt,
-                        context_request,
-                        project_name,
-                        buffer,
-                        range,
-                        model,
-                    ))
-                })??;
-
-            let language = buffer.language_at(range.start);
-            let language_name = if let Some(language) = language.as_ref() {
-                if Arc::ptr_eq(language, &language::PLAIN_TEXT) {
-                    None
-                } else {
-                    Some(language.name())
-                }
+        let snapshot = editor.read(cx).buffer().read(cx).snapshot(cx);
+        let range = codegen.read(cx).range.clone();
+        let start = snapshot.point_to_buffer_offset(range.start);
+        let end = snapshot.point_to_buffer_offset(range.end);
+        let (buffer, range) = if let Some((start, end)) = start.zip(end) {
+            let (start_buffer, start_buffer_offset) = start;
+            let (end_buffer, end_buffer_offset) = end;
+            if start_buffer.remote_id() == end_buffer.remote_id() {
+                (start_buffer.clone(), start_buffer_offset..end_buffer_offset)
            } else {
-                None
-            };
-
-            // Higher Temperature increases the randomness of model outputs.
-            // If Markdown or No Language is Known, increase the randomness for more creative output
-            // If Code, decrease temperature to get more deterministic outputs
-            let temperature = if let Some(language) = language_name.clone() {
-                if language.as_ref() == "Markdown" {
-                    1.0
-                } else {
-                    0.5
-                }
-            } else {
-                1.0
-            };
-
-            let prompt = cx
-                .background_executor()
-                .spawn(async move {
-                    let language_name = language_name.as_deref();
-                    let start = buffer.point_to_buffer_offset(range.start);
-                    let end = buffer.point_to_buffer_offset(range.end);
-                    let (buffer, range) = if let Some((start, end)) = start.zip(end) {
-                        let (start_buffer, start_buffer_offset) = start;
-                        let (end_buffer, end_buffer_offset) = end;
-                        if start_buffer.remote_id() == end_buffer.remote_id() {
-                            (start_buffer.clone(), start_buffer_offset..end_buffer_offset)
-                        } else {
-                            return Err(anyhow!("invalid transformation range"));
-                        }
-                    } else {
-                        return Err(anyhow!("invalid transformation range"));
-                    };
-                    generate_content_prompt(user_prompt, language_name, buffer, range, project_name)
-                })
-                .await?;
-
-            let mut messages = Vec::new();
-            if let Some(context_request) = context_request {
-                messages = context_request.messages;
+                self.finish_assist(assist_id, false, cx);
+                return;
            }
+        } else {
+            self.finish_assist(assist_id, false, cx);
+            return;
+        };
+
+        let language = buffer.language_at(range.start);
+        let language_name = if let Some(language) = language.as_ref() {
+            if Arc::ptr_eq(language, &language::PLAIN_TEXT) {
+                None
+            } else {
+                Some(language.name())
+            }
+        } else {
+            None
+        };
+
+        // Higher Temperature increases the randomness of model outputs.
+        // If Markdown or No Language is Known, increase the randomness for more creative output
+        // If Code, decrease temperature to get more deterministic outputs
+        let temperature = if let Some(language) = language_name.clone() {
+            if language.as_ref() == "Markdown" {
+                1.0
+            } else {
+                0.5
+            }
+        } else {
+            1.0
+        };
+
+        let prompt = cx.background_executor().spawn(async move {
+            let language_name = language_name.as_deref();
+            generate_content_prompt(user_prompt, language_name, buffer, range, project_name)
+        });
+
+        let mut messages = Vec::new();
+        if let Some(context) = context {
+            let request = context.read(cx).to_completion_request(cx);
+            messages = request.messages;
+        }
+        let model = CompletionProvider::global(cx).model();
+
+        cx.spawn(|mut cx| async move {
+            let prompt = prompt.await?;

            messages.push(LanguageModelRequestMessage {
                role: Role::User,
                content: prompt,
            });

-            Ok(LanguageModelRequest {
+            let request = LanguageModelRequest {
                model,
                messages,
                stop: vec!["|END|>".to_string()],
                temperature,
-            })
+            };
+
+            codegen.update(&mut cx, |codegen, cx| codegen.start(request, cx))?;
+            anyhow::Ok(())
        })
+        .detach_and_log_err(cx);
    }

    fn stop_assist(&mut self, assist_id: InlineAssistId, cx: &mut WindowContext) {
@@ -1170,7 +1142,6 @@ enum PromptEditorEvent {

 struct PromptEditor {
    id: InlineAssistId,
-    fs: Arc<dyn Fs>,
    height_in_lines: u8,
    editor: View<Editor>,
    edited_since_done: bool,
@@ -1179,12 +1150,9 @@ struct PromptEditor {
    prompt_history_ix: Option<usize>,
    pending_prompt: String,
    codegen: Model<Codegen>,
+    workspace: Option<WeakView<Workspace>>,
    _codegen_subscription: Subscription,
    editor_subscriptions: Vec<Subscription>,
-    pending_token_count: Task<Result<()>>,
-    token_count: Option<usize>,
-    _token_count_subscriptions: Vec<Subscription>,
-    workspace: Option<WeakView<Workspace>>,
 }

 impl EventEmitter<PromptEditorEvent> for PromptEditor {}
@@ -1192,7 +1160,6 @@ impl EventEmitter<PromptEditorEvent> for PromptEditor {}
 impl Render for PromptEditor {
    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
        let gutter_dimensions = *self.gutter_dimensions.lock();
-        let fs = self.fs.clone();

        let buttons = match &self.codegen.read(cx).status {
            CodegenStatus::Idle => {
@@ -1278,101 +1245,85 @@ impl Render for PromptEditor {
            }
        };

-        h_flex()
-            .bg(cx.theme().colors().editor_background)
-            .border_y_1()
-            .border_color(cx.theme().status().info_border)
-            .py_1p5()
-            .h_full()
-            .w_full()
-            .on_action(cx.listener(Self::confirm))
-            .on_action(cx.listener(Self::cancel))
-            .on_action(cx.listener(Self::move_up))
-            .on_action(cx.listener(Self::move_down))
-            .child(
-                h_flex()
-                    .w(gutter_dimensions.full_width() + (gutter_dimensions.margin / 2.0))
-                    .justify_center()
-                    .gap_2()
-                    .child(
-                        PopoverMenu::new("model-switcher")
-                            .menu(move |cx| {
-                                ContextMenu::build(cx, |mut menu, cx| {
-                                    for model in CompletionProvider::global(cx).available_models(cx)
-                                    {
-                                        menu = menu.custom_entry(
-                                            {
-                                                let model = model.clone();
-                                                move |_| {
-                                                    Label::new(model.display_name())
-                                                        .into_any_element()
-                                                }
-                                            },
-                                            {
-                                                let fs = fs.clone();
-                                                let model = model.clone();
-                                                move |cx| {
-                                                    let model = model.clone();
-                                                    update_settings_file::<AssistantSettings>(
-                                                        fs.clone(),
-                                                        cx,
-                                                        move |settings| settings.set_model(model),
-                                                    );
-                                                }
-                                            },
-                                        );
-                                    }
-                                    menu
+        v_flex().h_full().w_full().justify_end().child(
+            h_flex()
+                .bg(cx.theme().colors().editor_background)
+                .border_y_1()
+                .border_color(cx.theme().status().info_border)
+                .py_1p5()
+                .w_full()
+                .on_action(cx.listener(Self::confirm))
+                .on_action(cx.listener(Self::cancel))
+                .on_action(cx.listener(Self::move_up))
+                .on_action(cx.listener(Self::move_down))
+                .child(
+                    h_flex()
+                        .w(gutter_dimensions.full_width() + (gutter_dimensions.margin / 2.0))
+                        // .pr(gutter_dimensions.fold_area_width())
+                        .justify_center()
+                        .gap_2()
+                        .children(self.workspace.clone().map(|workspace| {
+                            IconButton::new("context", IconName::Context)
+                                .size(ButtonSize::None)
+                                .icon_size(IconSize::XSmall)
+                                .icon_color(Color::Muted)
+                                .on_click({
+                                    let workspace = workspace.clone();
+                                    cx.listener(move |_, _, cx| {
+                                        workspace
+                                            .update(cx, |workspace, cx| {
+                                                workspace.focus_panel::<AssistantPanel>(cx);
+                                            })
+                                            .ok();
+                                    })
                                })
-                                .into()
-                            })
-                            .trigger(
-                                IconButton::new("context", IconName::Settings)
-                                    .size(ButtonSize::None)
-                                    .icon_size(IconSize::Small)
-                                    .icon_color(Color::Muted)
-                                    .tooltip(move |cx| {
+                                .tooltip(move |cx| {
+                                    let token_count = workspace.upgrade().and_then(|workspace| {
+                                        let panel =
+                                            workspace.read(cx).panel::<AssistantPanel>(cx)?;
+                                        let context = panel.read(cx).active_context(cx)?;
+                                        context.read(cx).token_count()
+                                    });
+                                    if let Some(token_count) = token_count {
                                        Tooltip::with_meta(
                                            format!(
-                                                "Using {}",
-                                                CompletionProvider::global(cx)
-                                                    .model()
-                                                    .display_name()
+                                                "{} Additional Context Tokens from Assistant",
+                                                token_count
                                            ),
-                                            None,
-                                            "Click to Change Model",
+                                            Some(&crate::ToggleFocus),
+                                            "Click to open…",
                                            cx,
                                        )
-                                    }),
-                            )
-                            .anchor(gpui::AnchorCorner::BottomRight),
-                    )
-                    .children(
-                        if let CodegenStatus::Error(error) = &self.codegen.read(cx).status {
-                            let error_message = SharedString::from(error.to_string());
-                            Some(
-                                div()
-                                    .id("error")
-                                    .tooltip(move |cx| Tooltip::text(error_message.clone(), cx))
-                                    .child(
-                                        Icon::new(IconName::XCircle)
-                                            .size(IconSize::Small)
-                                            .color(Color::Error),
-                                    ),
-                            )
-                        } else {
-                            None
-                        },
-                    ),
-            )
-            .child(div().flex_1().child(self.render_prompt_editor(cx)))
-            .child(
-                h_flex()
-                    .gap_2()
-                    .pr_4()
-                    .children(self.render_token_count(cx))
-                    .children(buttons),
-            )
+                                    } else {
+                                        Tooltip::for_action(
+                                            "Toggle Assistant Panel",
+                                            &crate::ToggleFocus,
+                                            cx,
+                                        )
+                                    }
+                                })
+                        }))
+                        .children(
+                            if let CodegenStatus::Error(error) = &self.codegen.read(cx).status {
+                                let error_message = SharedString::from(error.to_string());
+                                Some(
+                                    div()
+                                        .id("error")
+                                        .tooltip(move |cx| Tooltip::text(error_message.clone(), cx))
+                                        .child(
+                                            Icon::new(IconName::XCircle)
+                                                .size(IconSize::Small)
+                                                .color(Color::Error),
+                                        ),
+                                )
+                            } else {
+                                None
+                            },
+                        ),
+                )
+                .child(div().flex_1().child(self.render_prompt_editor(cx)))
+                .child(h_flex().gap_2().pr_4().children(buttons)),
+        )
    }
 }

@@ -1385,17 +1336,13 @@ impl FocusableView for PromptEditor {
 impl PromptEditor {
    const MAX_LINES: u8 = 8;

-    #[allow(clippy::too_many_arguments)]
    fn new(
        id: InlineAssistId,
        gutter_dimensions: Arc<Mutex<GutterDimensions>>,
        prompt_history: VecDeque<String>,
        prompt_buffer: Model<MultiBuffer>,
        codegen: Model<Codegen>,
-        parent_editor: &View<Editor>,
-        assistant_panel: Option<&View<AssistantPanel>>,
        workspace: Option<WeakView<Workspace>>,
-        fs: Arc<dyn Fs>,
        cx: &mut ViewContext<Self>,
    ) -> Self {
        let prompt_editor = cx.new_view(|cx| {
@@ -1416,15 +1363,6 @@ impl PromptEditor {
            editor.set_placeholder_text("Add a prompt…", cx);
            editor
        });
-
-        let mut token_count_subscriptions = Vec::new();
-        token_count_subscriptions
-            .push(cx.subscribe(parent_editor, Self::handle_parent_editor_event));
-        if let Some(assistant_panel) = assistant_panel {
-            token_count_subscriptions
-                .push(cx.subscribe(assistant_panel, Self::handle_assistant_panel_event));
-        }
-
        let mut this = Self {
            id,
            height_in_lines: 1,
@@ -1437,14 +1375,9 @@ impl PromptEditor {
            _codegen_subscription: cx.observe(&codegen, Self::handle_codegen_changed),
            editor_subscriptions: Vec::new(),
            codegen,
-            fs,
-            pending_token_count: Task::ready(Ok(())),
-            token_count: None,
-            _token_count_subscriptions: token_count_subscriptions,
            workspace,
        };
        this.count_lines(cx);
-        this.count_tokens(cx);
        this.subscribe_to_editor(cx);
        this
    }
@@ -1503,47 +1436,6 @@ impl PromptEditor {
        }
    }

-    fn handle_parent_editor_event(
-        &mut self,
-        _: View<Editor>,
-        event: &EditorEvent,
-        cx: &mut ViewContext<Self>,
-    ) {
-        if let EditorEvent::BufferEdited { .. } = event {
-            self.count_tokens(cx);
-        }
-    }
-
-    fn handle_assistant_panel_event(
-        &mut self,
-        _: View<AssistantPanel>,
-        event: &AssistantPanelEvent,
-        cx: &mut ViewContext<Self>,
-    ) {
-        let AssistantPanelEvent::ContextEdited { .. } = event;
-        self.count_tokens(cx);
-    }
-
-    fn count_tokens(&mut self, cx: &mut ViewContext<Self>) {
-        let assist_id = self.id;
-        self.pending_token_count = cx.spawn(|this, mut cx| async move {
-            cx.background_executor().timer(Duration::from_secs(1)).await;
-            let request = cx
-                .update_global(|inline_assistant: &mut InlineAssistant, cx| {
-                    inline_assistant.request_for_inline_assist(assist_id, cx)
-                })?
-                .await?;
-
-            let token_count = cx
-                .update(|cx| CompletionProvider::global(cx).count_tokens(request, cx))?
-                .await?;
-            this.update(&mut cx, |this, cx| {
-                this.token_count = Some(token_count);
-                cx.notify();
-            })
-        })
-    }
-
    fn handle_prompt_editor_changed(&mut self, _: View<Editor>, cx: &mut ViewContext<Self>) {
        self.count_lines(cx);
    }
@@ -1568,9 +1460,6 @@ impl PromptEditor {
                self.edited_since_done = true;
                cx.notify();
            }
-            EditorEvent::BufferEdited => {
-                self.count_tokens(cx);
-            }
            _ => {}
        }
    }
@@ -1662,63 +1551,6 @@ impl PromptEditor {
        }
    }

-    fn render_token_count(&self, cx: &mut ViewContext<Self>) -> Option<impl IntoElement> {
-        let model = CompletionProvider::global(cx).model();
-        let token_count = self.token_count?;
-        let max_token_count = model.max_token_count();
-
-        let remaining_tokens = max_token_count as isize - token_count as isize;
-        let token_count_color = if remaining_tokens <= 0 {
-            Color::Error
-        } else if token_count as f32 / max_token_count as f32 >= 0.8 {
-            Color::Warning
-        } else {
-            Color::Muted
-        };
-
-        let mut token_count = h_flex()
-            .id("token_count")
-            .gap_0p5()
-            .child(
-                Label::new(humanize_token_count(token_count))
-                    .size(LabelSize::Small)
-                    .color(token_count_color),
-            )
-            .child(Label::new("/").size(LabelSize::Small).color(Color::Muted))
-            .child(
-                Label::new(humanize_token_count(max_token_count))
-                    .size(LabelSize::Small)
-                    .color(Color::Muted),
-            );
-        if let Some(workspace) = self.workspace.clone() {
-            token_count = token_count
-                .tooltip(|cx| {
-                    Tooltip::with_meta(
-                        "Tokens Used by Inline Assistant",
-                        None,
-                        "Click to Open Assistant Panel",
-                        cx,
-                    )
-                })
-                .cursor_pointer()
-                .on_mouse_down(gpui::MouseButton::Left, |_, cx| cx.stop_propagation())
-                .on_click(move |_, cx| {
-                    cx.stop_propagation();
-                    workspace
-                        .update(cx, |workspace, cx| {
-                            workspace.focus_panel::<AssistantPanel>(cx)
-                        })
-                        .ok();
-                });
-        } else {
-            token_count = token_count
-                .cursor_default()
-                .tooltip(|cx| Tooltip::text("Tokens Used by Inline Assistant", cx));
-        }
-
-        Some(token_count)
-    }
-
    fn render_prompt_editor(&self, cx: &mut ViewContext<Self>) -> impl IntoElement {
        let settings = ThemeSettings::get_global(cx);
        let text_style = TextStyle {
@@ -1730,7 +1562,7 @@ impl PromptEditor {
            font_family: settings.ui_font.family.clone(),
            font_features: settings.ui_font.features.clone(),
            font_size: rems(0.875).into(),
-            font_weight: settings.ui_font.weight,
+            font_weight: FontWeight::NORMAL,
            font_style: FontStyle::Normal,
            line_height: relative(1.3),
            background_color: None,
@@ -1986,14 +1818,13 @@ impl Codegen {
            .unwrap_or_else(|| snapshot.indent_size_for_line(MultiBufferRow(selection_start.row)));

        let model_telemetry_id = prompt.model.telemetry_id();
-        let response = CompletionProvider::global(cx).complete(prompt, cx);
+        let response = CompletionProvider::global(cx).complete(prompt);
        let telemetry = self.telemetry.clone();
        self.edit_position = range.start;
        self.diff = Diff::default();
        self.status = CodegenStatus::Pending;
        self.generation = cx.spawn(|this, mut cx| {
            async move {
-                let response = response.await;
                let generate = async {
                    let mut edit_start = range.start.to_offset(&snapshot);

@@ -2003,7 +1834,7 @@ impl Codegen {
                            let mut response_latency = None;
                            let request_start = Instant::now();
                            let diff = async {
-                                let chunks = StripInvalidSpans::new(response.inner.await?);
+                                let chunks = StripInvalidSpans::new(response.await?);
                                futures::pin_mut!(chunks);
                                let mut diff = StreamingDiff::new(selected_text.to_string());

@@ -2062,11 +1893,6 @@ impl Codegen {

                                        if lines.peek().is_some() {
                                            hunks_tx.send(diff.push_new("\n")).await?;
-                                            if line_indent.is_none() {
-                                                // Don't write out the leading indentation in empty lines on the next line
-                                                // This is the case where the above if statement didn't clear the buffer
-                                                new_text.clear();
-                                            }
                                            line_indent = None;
                                            first_line = false;
                                        }
@@ -2474,8 +2300,9 @@ mod tests {

    #[gpui::test(iterations = 10)]
    async fn test_transform_autoindent(cx: &mut TestAppContext, mut rng: StdRng) {
+        let provider = FakeCompletionProvider::default();
        cx.set_global(cx.update(SettingsStore::test));
-        let provider = cx.update(|cx| FakeCompletionProvider::setup_test(cx));
+        cx.set_global(CompletionProvider::Fake(provider.clone()));
        cx.update(language_settings::init);

        let text = indoc! {"
@@ -2495,11 +2322,8 @@ mod tests {
        });
        let codegen = cx.new_model(|cx| Codegen::new(buffer.clone(), range, None, cx));

-        codegen.update(cx, |codegen, cx| {
-            codegen.start(LanguageModelRequest::default(), cx)
-        });
-
-        cx.background_executor.run_until_parked();
+        let request = LanguageModelRequest::default();
+        codegen.update(cx, |codegen, cx| codegen.start(request, cx));

        let mut new_text = concat!(
            "       let mut x = 0;\n",
@@ -2511,11 +2335,11 @@ mod tests {
            let max_len = cmp::min(new_text.len(), 10);
            let len = rng.gen_range(1..=max_len);
            let (chunk, suffix) = new_text.split_at(len);
-            provider.send_completion(&LanguageModelRequest::default(), chunk.into());
+            provider.send_completion(chunk.into());
            new_text = suffix;
            cx.background_executor.run_until_parked();
        }
-        provider.finish_completion(&LanguageModelRequest::default());
+        provider.finish_completion();
        cx.background_executor.run_until_parked();

        assert_eq!(
@@ -2536,7 +2360,8 @@ mod tests {
        cx: &mut TestAppContext,
        mut rng: StdRng,
    ) {
-        let provider = cx.update(|cx| FakeCompletionProvider::setup_test(cx));
+        let provider = FakeCompletionProvider::default();
+        cx.set_global(CompletionProvider::Fake(provider.clone()));
        cx.set_global(cx.update(SettingsStore::test));
        cx.update(language_settings::init);

@@ -2557,8 +2382,6 @@ mod tests {
        let request = LanguageModelRequest::default();
        codegen.update(cx, |codegen, cx| codegen.start(request, cx));

-        cx.background_executor.run_until_parked();
-
        let mut new_text = concat!(
            "t mut x = 0;\n",
            "while x < 10 {\n",
@@ -2569,11 +2392,11 @@ mod tests {
            let max_len = cmp::min(new_text.len(), 10);
            let len = rng.gen_range(1..=max_len);
            let (chunk, suffix) = new_text.split_at(len);
-            provider.send_completion(&LanguageModelRequest::default(), chunk.into());
+            provider.send_completion(chunk.into());
            new_text = suffix;
            cx.background_executor.run_until_parked();
        }
-        provider.finish_completion(&LanguageModelRequest::default());
+        provider.finish_completion();
        cx.background_executor.run_until_parked();

        assert_eq!(
@@ -2594,7 +2417,8 @@ mod tests {
        cx: &mut TestAppContext,
        mut rng: StdRng,
    ) {
-        let provider = cx.update(|cx| FakeCompletionProvider::setup_test(cx));
+        let provider = FakeCompletionProvider::default();
+        cx.set_global(CompletionProvider::Fake(provider.clone()));
        cx.set_global(cx.update(SettingsStore::test));
        cx.update(language_settings::init);

@@ -2615,8 +2439,6 @@ mod tests {
        let request = LanguageModelRequest::default();
        codegen.update(cx, |codegen, cx| codegen.start(request, cx));

-        cx.background_executor.run_until_parked();
-
        let mut new_text = concat!(
            "let mut x = 0;\n",
            "while x < 10 {\n",
@@ -2627,11 +2449,11 @@ mod tests {
            let max_len = cmp::min(new_text.len(), 10);
            let len = rng.gen_range(1..=max_len);
            let (chunk, suffix) = new_text.split_at(len);
-            provider.send_completion(&LanguageModelRequest::default(), chunk.into());
+            provider.send_completion(chunk.into());
            new_text = suffix;
            cx.background_executor.run_until_parked();
        }
-        provider.finish_completion(&LanguageModelRequest::default());
+        provider.finish_completion();
        cx.background_executor.run_until_parked();

        assert_eq!(
--- a/crates/assistant/src/model_selector.rs
+++ b/crates/assistant/src/model_selector.rs
@@ -23,7 +23,7 @@ impl RenderOnce for ModelSelector {
            .with_handle(self.handle)
            .menu(move |cx| {
                ContextMenu::build(cx, |mut menu, cx| {
-                    for model in CompletionProvider::global(cx).available_models(cx) {
+                    for model in CompletionProvider::global(cx).available_models() {
                        menu = menu.custom_entry(
                            {
                                let model = model.clone();
@@ -79,6 +79,6 @@ impl RenderOnce for ModelSelector {
                        Tooltip::for_action("Change Model", &ToggleModelSelector, cx)
                    }),
            )
-            .attach(gpui::AnchorCorner::BottomLeft)
+            .anchor(gpui::AnchorCorner::BottomRight)
    }
 }
--- a/crates/assistant/src/prompt_library.rs
+++ b/crates/assistant/src/prompt_library.rs
@@ -5,17 +5,17 @@ use crate::{
 use anyhow::{anyhow, Result};
 use assistant_slash_command::SlashCommandRegistry;
 use chrono::{DateTime, Utc};
-use collections::{HashMap, HashSet};
-use editor::{actions::Tab, CurrentLineHighlight, Editor, EditorElement, EditorEvent, EditorStyle};
+use collections::HashMap;
+use editor::{actions::Tab, CurrentLineHighlight, Editor, EditorEvent};
 use futures::{
    future::{self, BoxFuture, Shared},
    FutureExt,
 };
 use fuzzy::StringMatchCandidate;
 use gpui::{
-    actions, point, size, transparent_black, AppContext, BackgroundExecutor, Bounds, EventEmitter,
-    Global, HighlightStyle, PromptLevel, ReadGlobal, Subscription, Task, TextStyle,
-    TitlebarOptions, UpdateGlobal, View, WindowBounds, WindowHandle, WindowOptions,
+    actions, percentage, point, size, Animation, AnimationExt, AppContext, BackgroundExecutor,
+    Bounds, EventEmitter, Global, PromptLevel, ReadGlobal, Subscription, Task, TitlebarOptions,
+    Transformation, UpdateGlobal, View, WindowBounds, WindowHandle, WindowOptions,
 };
 use heed::{types::SerdeBincode, Database, RoTxn};
 use language::{language_settings::SoftWrap, Buffer, LanguageRegistry};
@@ -34,7 +34,7 @@ use std::{
 use theme::ThemeSettings;
 use ui::{
    div, prelude::*, IconButtonShape, ListItem, ListItemSpacing, ParentElement, Render,
-    SharedString, Styled, Tooltip, ViewContext, VisualContext,
+    SharedString, Styled, TitleBar, Tooltip, ViewContext, VisualContext,
 };
 use util::{ResultExt, TryFutureExt};
 use uuid::Uuid;
@@ -42,12 +42,7 @@ use workspace::Workspace;

 actions!(
    prompt_library,
-    [
-        NewPrompt,
-        DeletePrompt,
-        DuplicatePrompt,
-        ToggleDefaultPrompt
-    ]
+    [NewPrompt, DeletePrompt, ToggleDefaultPrompt]
 );

 /// Init starts loading the PromptStore in the background and assigns
@@ -114,13 +109,12 @@ pub struct PromptLibrary {
 }

 struct PromptEditor {
-    title_editor: View<Editor>,
-    body_editor: View<Editor>,
+    editor: View<Editor>,
    token_count: Option<usize>,
    pending_token_count: Task<Option<()>>,
-    next_title_and_body_to_save: Option<(String, Rope)>,
+    next_body_to_save: Option<Rope>,
    pending_save: Option<Task<Option<()>>>,
-    _subscriptions: Vec<Subscription>,
+    _subscription: Subscription,
 }

 struct PromptPickerDelegate {
@@ -351,8 +345,7 @@ impl PromptLibrary {

        let prompt_metadata = self.store.metadata(prompt_id).unwrap();
        let prompt_editor = self.prompt_editors.get_mut(&prompt_id).unwrap();
-        let title = prompt_editor.title_editor.read(cx).text(cx);
-        let body = prompt_editor.body_editor.update(cx, |editor, cx| {
+        let body = prompt_editor.editor.update(cx, |editor, cx| {
            editor
                .buffer()
                .read(cx)
@@ -366,24 +359,20 @@ impl PromptLibrary {
        let store = self.store.clone();
        let executor = cx.background_executor().clone();

-        prompt_editor.next_title_and_body_to_save = Some((title, body));
+        prompt_editor.next_body_to_save = Some(body);
        if prompt_editor.pending_save.is_none() {
            prompt_editor.pending_save = Some(cx.spawn(|this, mut cx| {
                async move {
                    loop {
-                        let title_and_body = this.update(&mut cx, |this, _| {
+                        let next_body_to_save = this.update(&mut cx, |this, _| {
                            this.prompt_editors
                                .get_mut(&prompt_id)?
-                                .next_title_and_body_to_save
+                                .next_body_to_save
                                .take()
                        })?;

-                        if let Some((title, body)) = title_and_body {
-                            let title = if title.trim().is_empty() {
-                                None
-                            } else {
-                                Some(SharedString::from(title))
-                            };
+                        if let Some(body) = next_body_to_save {
+                            let title = title_from_body(body.chars_at(0));
                            store
                                .save(prompt_id, title, prompt_metadata.default, body)
                                .await
@@ -416,12 +405,6 @@ impl PromptLibrary {
        }
    }

-    pub fn duplicate_active_prompt(&mut self, cx: &mut ViewContext<Self>) {
-        if let Some(active_prompt_id) = self.active_prompt_id {
-            self.duplicate_prompt(active_prompt_id, cx);
-        }
-    }
-
    pub fn toggle_default_for_active_prompt(&mut self, cx: &mut ViewContext<Self>) {
        if let Some(active_prompt_id) = self.active_prompt_id {
            self.toggle_default_for_prompt(active_prompt_id, cx);
@@ -442,11 +425,11 @@ impl PromptLibrary {
        if let Some(prompt_editor) = self.prompt_editors.get(&prompt_id) {
            if focus {
                prompt_editor
-                    .body_editor
+                    .editor
                    .update(cx, |editor, cx| editor.focus(cx));
            }
            self.set_active_prompt(Some(prompt_id), cx);
-        } else if let Some(prompt_metadata) = self.store.metadata(prompt_id) {
+        } else {
            let language_registry = self.language_registry.clone();
            let commands = SlashCommandRegistry::global(cx);
            let prompt = self.store.load(prompt_id);
@@ -455,20 +438,13 @@ impl PromptLibrary {
                let markdown = language_registry.language_for_name("Markdown").await;
                this.update(&mut cx, |this, cx| match prompt {
                    Ok(prompt) => {
-                        let title_editor = cx.new_view(|cx| {
-                            let mut editor = Editor::auto_width(cx);
-                            editor.set_placeholder_text("Untitled", cx);
-                            editor.set_text(prompt_metadata.title.unwrap_or_default(), cx);
-                            editor
+                        let buffer = cx.new_model(|cx| {
+                            let mut buffer = Buffer::local(prompt, cx);
+                            buffer.set_language(markdown.log_err(), cx);
+                            buffer.set_language_registry(language_registry);
+                            buffer
                        });
-                        let body_editor = cx.new_view(|cx| {
-                            let buffer = cx.new_model(|cx| {
-                                let mut buffer = Buffer::local(prompt, cx);
-                                buffer.set_language(markdown.log_err(), cx);
-                                buffer.set_language_registry(language_registry);
-                                buffer
-                            });
-
+                        let editor = cx.new_view(|cx| {
                            let mut editor = Editor::for_buffer(buffer, None, cx);
                            editor.set_soft_wrap_mode(SoftWrap::EditorWidth, cx);
                            editor.set_show_gutter(false, cx);
@@ -484,24 +460,19 @@ impl PromptLibrary {
                            }
                            editor
                        });
-                        let _subscriptions = vec![
-                            cx.subscribe(&title_editor, move |this, editor, event, cx| {
-                                this.handle_prompt_title_editor_event(prompt_id, editor, event, cx)
-                            }),
-                            cx.subscribe(&body_editor, move |this, editor, event, cx| {
-                                this.handle_prompt_body_editor_event(prompt_id, editor, event, cx)
-                            }),
-                        ];
+                        let _subscription =
+                            cx.subscribe(&editor, move |this, _editor, event, cx| {
+                                this.handle_prompt_editor_event(prompt_id, event, cx)
+                            });
                        this.prompt_editors.insert(
                            prompt_id,
                            PromptEditor {
-                                title_editor,
-                                body_editor,
-                                next_title_and_body_to_save: None,
+                                editor,
+                                next_body_to_save: None,
                                pending_save: None,
                                token_count: None,
                                pending_token_count: Task::ready(None),
-                                _subscriptions,
+                                _subscription,
                            },
                        );
                        this.set_active_prompt(Some(prompt_id), cx);
@@ -575,51 +546,10 @@ impl PromptLibrary {
        }
    }

-    pub fn duplicate_prompt(&mut self, prompt_id: PromptId, cx: &mut ViewContext<Self>) {
-        if let Some(prompt) = self.prompt_editors.get(&prompt_id) {
-            const DUPLICATE_SUFFIX: &str = " copy";
-            let title_to_duplicate = prompt.title_editor.read(cx).text(cx);
-            let existing_titles = self
-                .prompt_editors
-                .iter()
-                .filter(|&(&id, _)| id != prompt_id)
-                .map(|(_, prompt_editor)| prompt_editor.title_editor.read(cx).text(cx))
-                .filter(|title| title.starts_with(&title_to_duplicate))
-                .collect::<HashSet<_>>();
-
-            let title = if existing_titles.is_empty() {
-                title_to_duplicate + DUPLICATE_SUFFIX
-            } else {
-                let mut i = 1;
-                loop {
-                    let new_title = format!("{title_to_duplicate}{DUPLICATE_SUFFIX} {i}");
-                    if !existing_titles.contains(&new_title) {
-                        break new_title;
-                    }
-                    i += 1;
-                }
-            };
-
-            let new_id = PromptId::new();
-            let body = prompt.body_editor.read(cx).text(cx);
-            let save = self
-                .store
-                .save(new_id, Some(title.into()), false, body.into());
-            self.picker.update(cx, |picker, cx| picker.refresh(cx));
-            cx.spawn(|this, mut cx| async move {
-                save.await?;
-                this.update(&mut cx, |prompt_library, cx| {
-                    prompt_library.load_prompt(new_id, true, cx)
-                })
-            })
-            .detach_and_log_err(cx);
-        }
-    }
-
    fn focus_active_prompt(&mut self, _: &Tab, cx: &mut ViewContext<Self>) {
        if let Some(active_prompt) = self.active_prompt_id {
            self.prompt_editors[&active_prompt]
-                .body_editor
+                .editor
                .update(cx, |editor, cx| editor.focus(cx));
            cx.stop_propagation();
        }
@@ -635,11 +565,11 @@ impl PromptLibrary {
            return;
        };

-        let prompt_editor = &self.prompt_editors[&active_prompt_id].body_editor;
+        let prompt_editor = &self.prompt_editors[&active_prompt_id].editor;
        let provider = CompletionProvider::global(cx);
        if provider.is_authenticated() {
            InlineAssistant::update_global(cx, |assistant, cx| {
-                assistant.assist(&prompt_editor, None, None, cx)
+                assistant.assist(&prompt_editor, None, false, cx)
            })
        } else {
            for window in cx.windows() {
@@ -659,73 +589,50 @@ impl PromptLibrary {
        }
    }

-    fn move_down_from_title(&mut self, _: &editor::actions::MoveDown, cx: &mut ViewContext<Self>) {
-        if let Some(prompt_id) = self.active_prompt_id {
-            if let Some(prompt_editor) = self.prompt_editors.get(&prompt_id) {
-                cx.focus_view(&prompt_editor.body_editor);
-            }
-        }
-    }
-
-    fn move_up_from_body(&mut self, _: &editor::actions::MoveUp, cx: &mut ViewContext<Self>) {
-        if let Some(prompt_id) = self.active_prompt_id {
-            if let Some(prompt_editor) = self.prompt_editors.get(&prompt_id) {
-                cx.focus_view(&prompt_editor.title_editor);
-            }
-        }
-    }
-
-    fn handle_prompt_title_editor_event(
+    fn handle_prompt_editor_event(
        &mut self,
        prompt_id: PromptId,
-        title_editor: View<Editor>,
        event: &EditorEvent,
        cx: &mut ViewContext<Self>,
    ) {
-        match event {
-            EditorEvent::BufferEdited => {
-                self.save_prompt(prompt_id, cx);
-                self.count_tokens(prompt_id, cx);
-            }
-            EditorEvent::Blurred => {
-                title_editor.update(cx, |title_editor, cx| {
-                    title_editor.change_selections(None, cx, |selections| {
-                        let cursor = selections.oldest_anchor().head();
-                        selections.select_anchor_ranges([cursor..cursor]);
-                    });
-                });
-            }
-            _ => {}
-        }
-    }
+        if let EditorEvent::BufferEdited = event {
+            let prompt_editor = self.prompt_editors.get(&prompt_id).unwrap();
+            let buffer = prompt_editor
+                .editor
+                .read(cx)
+                .buffer()
+                .read(cx)
+                .as_singleton()
+                .unwrap();

-    fn handle_prompt_body_editor_event(
-        &mut self,
-        prompt_id: PromptId,
-        body_editor: View<Editor>,
-        event: &EditorEvent,
-        cx: &mut ViewContext<Self>,
-    ) {
-        match event {
-            EditorEvent::BufferEdited => {
-                self.save_prompt(prompt_id, cx);
-                self.count_tokens(prompt_id, cx);
-            }
-            EditorEvent::Blurred => {
-                body_editor.update(cx, |body_editor, cx| {
-                    body_editor.change_selections(None, cx, |selections| {
-                        let cursor = selections.oldest_anchor().head();
-                        selections.select_anchor_ranges([cursor..cursor]);
-                    });
-                });
-            }
-            _ => {}
+            buffer.update(cx, |buffer, cx| {
+                let mut chars = buffer.chars_at(0);
+                match chars.next() {
+                    Some('#') => {
+                        if chars.next() != Some(' ') {
+                            drop(chars);
+                            buffer.edit([(1..1, " ")], None, cx);
+                        }
+                    }
+                    Some(' ') => {
+                        drop(chars);
+                        buffer.edit([(0..0, "#")], None, cx);
+                    }
+                    _ => {
+                        drop(chars);
+                        buffer.edit([(0..0, "# ")], None, cx);
+                    }
+                }
+            });
+
+            self.save_prompt(prompt_id, cx);
+            self.count_tokens(prompt_id, cx);
        }
    }

    fn count_tokens(&mut self, prompt_id: PromptId, cx: &mut ViewContext<Self>) {
        if let Some(prompt) = self.prompt_editors.get_mut(&prompt_id) {
-            let editor = &prompt.body_editor.read(cx);
+            let editor = &prompt.editor.read(cx);
            let buffer = &editor.buffer().read(cx).as_singleton().unwrap().read(cx);
            let body = buffer.as_rope().clone();
            prompt.pending_token_count = cx.spawn(|this, mut cx| {
@@ -773,7 +680,7 @@ impl PromptLibrary {
            .child(
                h_flex()
                    .p(Spacing::Small.rems(cx))
-                    .h_9()
+                    .h(TitleBar::height(cx))
                    .w_full()
                    .flex_none()
                    .justify_end()
@@ -801,218 +708,122 @@ impl PromptLibrary {
            .flex_none()
            .min_w_64()
            .children(self.active_prompt_id.and_then(|prompt_id| {
+                let buffer_font = ThemeSettings::get_global(cx).buffer_font.family.clone();
                let prompt_metadata = self.store.metadata(prompt_id)?;
                let prompt_editor = &self.prompt_editors[&prompt_id];
-                let focus_handle = prompt_editor.body_editor.focus_handle(cx);
+                let focus_handle = prompt_editor.editor.focus_handle(cx);
                let current_model = CompletionProvider::global(cx).model();
-                let settings = ThemeSettings::get_global(cx);
+                let token_count = prompt_editor.token_count.map(|count| count.to_string());

                Some(
-                    v_flex()
+                    h_flex()
                        .id("prompt-editor-inner")
                        .size_full()
-                        .relative()
-                        .overflow_hidden()
-                        .pl(Spacing::XXLarge.rems(cx))
-                        .pt(Spacing::Large.rems(cx))
+                        .items_start()
                        .on_click(cx.listener(move |_, _, cx| {
                            cx.focus(&focus_handle);
                        }))
-                        .child(
-                            h_flex()
-                                .group("active-editor-header")
-                                .pr(Spacing::XXLarge.rems(cx))
-                                .pt(Spacing::XSmall.rems(cx))
-                                .pb(Spacing::Large.rems(cx))
-                                .justify_between()
-                                .child(
-                                    h_flex().gap_1().child(
-                                        div()
-                                            .max_w_80()
-                                            .on_action(cx.listener(Self::move_down_from_title))
-                                            .border_1()
-                                            .border_color(transparent_black())
-                                            .rounded_md()
-                                            .group_hover("active-editor-header", |this| {
-                                                this.border_color(
-                                                    cx.theme().colors().border_variant,
-                                                )
-                                            })
-                                            .child(EditorElement::new(
-                                                &prompt_editor.title_editor,
-                                                EditorStyle {
-                                                    background: cx.theme().system().transparent,
-                                                    local_player: cx.theme().players().local(),
-                                                    text: TextStyle {
-                                                        color: cx
-                                                            .theme()
-                                                            .colors()
-                                                            .editor_foreground,
-                                                        font_family: settings
-                                                            .ui_font
-                                                            .family
-                                                            .clone(),
-                                                        font_features: settings
-                                                            .ui_font
-                                                            .features
-                                                            .clone(),
-                                                        font_size: HeadlineSize::Large
-                                                            .size()
-                                                            .into(),
-                                                        font_weight: settings.ui_font.weight,
-                                                        line_height: relative(
-                                                            settings.buffer_line_height.value(),
-                                                        ),
-                                                        ..Default::default()
-                                                    },
-                                                    scrollbar_width: Pixels::ZERO,
-                                                    syntax: cx.theme().syntax().clone(),
-                                                    status: cx.theme().status().clone(),
-                                                    inlay_hints_style: HighlightStyle {
-                                                        color: Some(cx.theme().status().hint),
-                                                        ..HighlightStyle::default()
-                                                    },
-                                                    suggestions_style: HighlightStyle {
-                                                        color: Some(cx.theme().status().predictive),
-                                                        ..HighlightStyle::default()
-                                                    },
-                                                },
-                                            )),
-                                    ),
-                                )
-                                .child(
-                                    h_flex()
-                                        .h_full()
-                                        .child(
-                                            h_flex()
-                                                .h_full()
-                                                .gap(Spacing::XXLarge.rems(cx))
-                                                .child(div()),
-                                        )
-                                        .child(
-                                            h_flex()
-                                                .h_full()
-                                                .gap(Spacing::XXLarge.rems(cx))
-                                                .children(prompt_editor.token_count.map(
-                                                    |token_count| {
-                                                        let token_count: SharedString =
-                                                            token_count.to_string().into();
-                                                        let label_token_count: SharedString =
-                                                            token_count.to_string().into();
-
-                                                        h_flex()
-                                                            .id("token_count")
-                                                            .tooltip(move |cx| {
-                                                                let token_count =
-                                                                    token_count.clone();
-
-                                                                Tooltip::with_meta(
-                                                                    format!(
-                                                                        "{} tokens",
-                                                                        token_count.clone()
-                                                                    ),
-                                                                    None,
-                                                                    format!(
-                                                                        "Model: {}",
-                                                                        current_model
-                                                                            .display_name()
-                                                                    ),
-                                                                    cx,
-                                                                )
-                                                            })
-                                                            .child(
-                                                                Label::new(format!(
-                                                                    "{} tokens",
-                                                                    label_token_count.clone()
-                                                                ))
-                                                                .color(Color::Muted),
-                                                            )
-                                                    },
-                                                ))
-                                                .child(
-                                                    IconButton::new(
-                                                        "delete-prompt",
-                                                        IconName::Trash,
-                                                    )
-                                                    .size(ButtonSize::Large)
-                                                    .style(ButtonStyle::Transparent)
-                                                    .shape(IconButtonShape::Square)
-                                                    .size(ButtonSize::Large)
-                                                    .tooltip(move |cx| {
-                                                        Tooltip::for_action(
-                                                            "Delete Prompt",
-                                                            &DeletePrompt,
-                                                            cx,
-                                                        )
-                                                    })
-                                                    .on_click(|_, cx| {
-                                                        cx.dispatch_action(Box::new(DeletePrompt));
-                                                    }),
-                                                )
-                                                .child(
-                                                    IconButton::new(
-                                                        "duplicate-prompt",
-                                                        IconName::BookCopy,
-                                                    )
-                                                    .size(ButtonSize::Large)
-                                                    .style(ButtonStyle::Transparent)
-                                                    .shape(IconButtonShape::Square)
-                                                    .size(ButtonSize::Large)
-                                                    .tooltip(move |cx| {
-                                                        Tooltip::for_action(
-                                                            "Duplicate Prompt",
-                                                            &DuplicatePrompt,
-                                                            cx,
-                                                        )
-                                                    })
-                                                    .on_click(|_, cx| {
-                                                        cx.dispatch_action(Box::new(
-                                                            DuplicatePrompt,
-                                                        ));
-                                                    }),
-                                                )
-                                                .child(
-                                                    IconButton::new(
-                                                        "toggle-default-prompt",
-                                                        IconName::Sparkle,
-                                                    )
-                                                    .style(ButtonStyle::Transparent)
-                                                    .selected(prompt_metadata.default)
-                                                    .selected_icon(IconName::SparkleFilled)
-                                                    .icon_color(if prompt_metadata.default {
-                                                        Color::Accent
-                                                    } else {
-                                                        Color::Muted
-                                                    })
-                                                    .shape(IconButtonShape::Square)
-                                                    .size(ButtonSize::Large)
-                                                    .tooltip(move |cx| {
-                                                        Tooltip::text(
-                                                            if prompt_metadata.default {
-                                                                "Remove from Default Prompt"
-                                                            } else {
-                                                                "Add to Default Prompt"
-                                                            },
-                                                            cx,
-                                                        )
-                                                    })
-                                                    .on_click(|_, cx| {
-                                                        cx.dispatch_action(Box::new(
-                                                            ToggleDefaultPrompt,
-                                                        ));
-                                                    }),
-                                                ),
-                                        ),
-                                ),
-                        )
                        .child(
                            div()
                                .on_action(cx.listener(Self::focus_picker))
                                .on_action(cx.listener(Self::inline_assist))
-                                .on_action(cx.listener(Self::move_up_from_body))
                                .flex_grow()
                                .h_full()
-                                .child(prompt_editor.body_editor.clone()),
+                                .pt(Spacing::XXLarge.rems(cx))
+                                .pl(Spacing::XXLarge.rems(cx))
+                                .child(prompt_editor.editor.clone()),
+                        )
+                        .child(
+                            v_flex()
+                                .w_12()
+                                .py(Spacing::Large.rems(cx))
+                                .justify_start()
+                                .items_end()
+                                .gap_1()
+                                .child(h_flex().h_8().font_family(buffer_font).when_some_else(
+                                    token_count,
+                                    |tokens_ready, token_count| {
+                                        tokens_ready.pr_3().justify_end().child(
+                                            // This isn't actually a button, it just let's us easily add
+                                            // a tooltip to the token count.
+                                            Button::new("token_count", token_count.clone())
+                                                .style(ButtonStyle::Transparent)
+                                                .color(Color::Muted)
+                                                .tooltip(move |cx| {
+                                                    Tooltip::with_meta(
+                                                        format!("{} tokens", token_count,),
+                                                        None,
+                                                        format!(
+                                                            "Model: {}",
+                                                            current_model.display_name()
+                                                        ),
+                                                        cx,
+                                                    )
+                                                }),
+                                        )
+                                    },
+                                    |tokens_loading| {
+                                        tokens_loading.w_12().justify_center().child(
+                                            Icon::new(IconName::ArrowCircle)
+                                                .size(IconSize::Small)
+                                                .color(Color::Muted)
+                                                .with_animation(
+                                                    "arrow-circle",
+                                                    Animation::new(Duration::from_secs(4)).repeat(),
+                                                    |icon, delta| {
+                                                        icon.transform(Transformation::rotate(
+                                                            percentage(delta),
+                                                        ))
+                                                    },
+                                                ),
+                                        )
+                                    },
+                                ))
+                                .child(
+                                    h_flex().justify_center().w_12().h_8().child(
+                                        IconButton::new("toggle-default-prompt", IconName::Sparkle)
+                                            .style(ButtonStyle::Transparent)
+                                            .selected(prompt_metadata.default)
+                                            .selected_icon(IconName::SparkleFilled)
+                                            .icon_color(if prompt_metadata.default {
+                                                Color::Accent
+                                            } else {
+                                                Color::Muted
+                                            })
+                                            .shape(IconButtonShape::Square)
+                                            .tooltip(move |cx| {
+                                                Tooltip::text(
+                                                    if prompt_metadata.default {
+                                                        "Remove from Default Prompt"
+                                                    } else {
+                                                        "Add to Default Prompt"
+                                                    },
+                                                    cx,
+                                                )
+                                            })
+                                            .on_click(|_, cx| {
+                                                cx.dispatch_action(Box::new(ToggleDefaultPrompt));
+                                            }),
+                                    ),
+                                )
+                                .child(
+                                    h_flex().justify_center().w_12().h_8().child(
+                                        IconButton::new("delete-prompt", IconName::Trash)
+                                            .size(ButtonSize::Large)
+                                            .style(ButtonStyle::Transparent)
+                                            .shape(IconButtonShape::Square)
+                                            .tooltip(move |cx| {
+                                                Tooltip::for_action(
+                                                    "Delete Prompt",
+                                                    &DeletePrompt,
+                                                    cx,
+                                                )
+                                            })
+                                            .on_click(|_, cx| {
+                                                cx.dispatch_action(Box::new(DeletePrompt));
+                                            }),
+                                    ),
+                                ),
                        ),
                )
            }))
@@ -1029,7 +840,6 @@ impl Render for PromptLibrary {
            .key_context("PromptLibrary")
            .on_action(cx.listener(|this, &NewPrompt, cx| this.new_prompt(cx)))
            .on_action(cx.listener(|this, &DeletePrompt, cx| this.delete_active_prompt(cx)))
-            .on_action(cx.listener(|this, &DuplicatePrompt, cx| this.duplicate_active_prompt(cx)))
            .on_action(cx.listener(|this, &ToggleDefaultPrompt, cx| {
                this.toggle_default_for_active_prompt(cx)
            }))
@@ -1305,3 +1115,24 @@ pub struct GlobalPromptStore(
 );

 impl Global for GlobalPromptStore {}
+
+fn title_from_body(body: impl IntoIterator<Item = char>) -> Option<SharedString> {
+    let mut chars = body.into_iter().take_while(|c| *c != '\n').peekable();
+
+    let mut level = 0;
+    while let Some('#') = chars.peek() {
+        level += 1;
+        chars.next();
+    }
+
+    if level > 0 {
+        let title = chars.collect::<String>().trim().to_string();
+        if title.is_empty() {
+            None
+        } else {
+            Some(title.into())
+        }
+    } else {
+        None
+    }
+}
--- a/crates/assistant/src/prompts.rs
+++ b/crates/assistant/src/prompts.rs
@@ -6,130 +6,118 @@ pub fn generate_content_prompt(
    language_name: Option<&str>,
    buffer: BufferSnapshot,
    range: Range<usize>,
-    _project_name: Option<String>,
+    project_name: Option<String>,
 ) -> anyhow::Result<String> {
    let mut prompt = String::new();

    let content_type = match language_name {
        None | Some("Markdown" | "Plain Text") => {
-            writeln!(
-                prompt,
-                "Here's a file of text that I'm going to ask you to make an edit to."
-            )?;
-            "text"
+            writeln!(prompt, "You are an expert engineer.")?;
+            "Text"
        }
        Some(language_name) => {
+            writeln!(prompt, "You are an expert {language_name} engineer.")?;
            writeln!(
                prompt,
-                "Here's a file of {language_name} that I'm going to ask you to make an edit to."
+                "Your answer MUST always and only be valid {}.",
+                language_name
            )?;
-            "code"
+            "Code"
        }
    };

-    const MAX_CTX: usize = 50000;
-    let mut is_truncated = false;
+    if let Some(project_name) = project_name {
+        writeln!(
+            prompt,
+            "You are currently working inside the '{project_name}' project in code editor Zed."
+        )?;
+    }
+
+    writeln!(
+        prompt,
+        "The user has the following file open in the editor:"
+    )?;
    if range.is_empty() {
-        prompt.push_str("The point you'll need to insert at is marked with <insert_here></insert_here>.\n\n<document>");
+        write!(prompt, "```")?;
+        if let Some(language_name) = language_name {
+            write!(prompt, "{language_name}")?;
+        }
+
+        for chunk in buffer.as_rope().chunks_in_range(0..range.start) {
+            prompt.push_str(chunk);
+        }
+        prompt.push_str("<|CURSOR|>");
+        for chunk in buffer.as_rope().chunks_in_range(range.start..buffer.len()) {
+            prompt.push_str(chunk);
+        }
+        if !prompt.ends_with('\n') {
+            prompt.push('\n');
+        }
+        writeln!(prompt, "```")?;
+        prompt.push('\n');
+
+        writeln!(
+            prompt,
+            "Assume the cursor is located where the `<|CURSOR|>` span is."
+        )
+        .unwrap();
+        writeln!(
+            prompt,
+            "{content_type} can't be replaced, so assume your answer will be inserted at the cursor.",
+        )
+        .unwrap();
+        writeln!(
+            prompt,
+            "Generate {content_type} based on the users prompt: {user_prompt}",
+        )
+        .unwrap();
    } else {
-        prompt.push_str("The section you'll need to rewrite is marked with <rewrite_this></rewrite_this> tags.\n\n<document>");
-    }
-    // Include file content.
-    let before_range = 0..range.start;
-    let truncated_before = if before_range.len() > MAX_CTX {
-        is_truncated = true;
-        range.start - MAX_CTX..range.start
-    } else {
-        before_range
-    };
-    let mut non_rewrite_len = truncated_before.len();
-    for chunk in buffer.text_for_range(truncated_before) {
-        prompt.push_str(chunk);
-    }
-    if !range.is_empty() {
-        prompt.push_str("<rewrite_this>\n");
+        write!(prompt, "```")?;
+        for chunk in buffer.as_rope().chunks() {
+            prompt.push_str(chunk);
+        }
+        if !prompt.ends_with('\n') {
+            prompt.push('\n');
+        }
+        writeln!(prompt, "```")?;
+        prompt.push('\n');
+
+        writeln!(
+            prompt,
+            "In particular, the following piece of text is selected:"
+        )?;
+        write!(prompt, "```")?;
+        if let Some(language_name) = language_name {
+            write!(prompt, "{language_name}")?;
+        }
+        prompt.push('\n');
        for chunk in buffer.text_for_range(range.clone()) {
            prompt.push_str(chunk);
        }
-        prompt.push_str("\n<rewrite_this>");
-    } else {
-        prompt.push_str("<insert_here></insert_here>");
-    }
-    let after_range = range.end..buffer.len();
-    let truncated_after = if after_range.len() > MAX_CTX {
-        is_truncated = true;
-        range.end..range.end + MAX_CTX
-    } else {
-        after_range
-    };
-    non_rewrite_len += truncated_after.len();
-    for chunk in buffer.text_for_range(truncated_after) {
-        prompt.push_str(chunk);
-    }
-
-    write!(prompt, "</document>\n\n").unwrap();
-
-    if is_truncated {
-        writeln!(prompt, "The context around the relevant section has been truncated (possibly in the middle of a line) for brevity.\n")?;
-    }
-
-    if range.is_empty() {
-        writeln!(
-                prompt,
-                "You can't replace {content_type}, your answer will be inserted in place of the `<insert_here></insert_here>` tags. Don't include the insert_here tags in your output.",
-            )
-            .unwrap();
-        writeln!(
-                prompt,
-                "Generate {content_type} based on the following prompt:\n\n<prompt>\n{user_prompt}\n</prompt>",
-            )
-            .unwrap();
-        writeln!(prompt, "Match the indentation in the original file in the inserted {content_type}, don't include any indentation on blank lines.\n").unwrap();
-        prompt.push_str("Immediately start with the following format with no remarks:\n\n```\n{{INSERTED_CODE}}\n```");
-    } else {
-        writeln!(prompt, "Edit the section of {content_type} in <rewrite_this></rewrite_this> tags based on the following prompt:'").unwrap();
-        writeln!(prompt, "\n<prompt>\n{user_prompt}\n</prompt>\n").unwrap();
-        let rewrite_len = range.end - range.start;
-        if rewrite_len < 20000 && rewrite_len * 2 < non_rewrite_len {
-            writeln!(prompt, "And here's the section to rewrite based on that prompt again for reference:\n\n<rewrite_this>\n").unwrap();
-            for chunk in buffer.text_for_range(range.clone()) {
-                prompt.push_str(chunk);
-            }
-            writeln!(prompt, "\n</rewrite_this>\n").unwrap();
+        if !prompt.ends_with('\n') {
+            prompt.push('\n');
        }
-        writeln!(prompt, "Only make changes that are necessary to fulfill the prompt, leave everything else as-is. All surrounding {content_type} will be preserved.\n").unwrap();
-        write!(
+        writeln!(prompt, "```")?;
+        prompt.push('\n');
+
+        writeln!(
            prompt,
-            "Start at the indentation level in the original file in the rewritten {content_type}. "
+            "Modify the user's selected {content_type} based upon the users prompt: {user_prompt}"
+        )
+        .unwrap();
+        writeln!(
+            prompt,
+            "You must reply with only the adjusted {content_type}, not the entire file."
        )
        .unwrap();
-        prompt.push_str("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.");
-        prompt.push_str("\n\nImmediately start with the following format with no remarks:\n\n```\n{{REWRITTEN_CODE}}\n```");
    }

+    writeln!(prompt, "Never make remarks about the output.").unwrap();
+    writeln!(
+        prompt,
+        "Do not return anything else, except the generated {content_type}."
+    )
+    .unwrap();
+
    Ok(prompt)
 }
-
-pub fn generate_terminal_assistant_prompt(
-    user_prompt: &str,
-    shell: Option<&str>,
-    working_directory: Option<&str>,
-) -> String {
-    let mut prompt = String::new();
-    writeln!(&mut prompt, "You are an expert terminal user.").unwrap();
-    writeln!(&mut prompt, "You will be given a description of a command and you need to respond with a command that matches the description.").unwrap();
-    writeln!(&mut prompt, "Do not include markdown blocks or any other text formatting in your response, always respond with a single command that can be executed in the given shell.").unwrap();
-    if let Some(shell) = shell {
-        writeln!(&mut prompt, "Current shell is '{shell}'.").unwrap();
-    }
-    if let Some(working_directory) = working_directory {
-        writeln!(
-            &mut prompt,
-            "Current working directory is '{working_directory}'."
-        )
-        .unwrap();
-    }
-    writeln!(&mut prompt, "Here is the description of the command:").unwrap();
-    prompt.push_str(user_prompt);
-    prompt
-}
--- a/crates/assistant/src/slash_command.rs
+++ b/crates/assistant/src/slash_command.rs
@@ -20,12 +20,12 @@ use workspace::Workspace;
 pub mod active_command;
 pub mod default_command;
 pub mod diagnostics_command;
-pub mod docs_command;
 pub mod fetch_command;
 pub mod file_command;
 pub mod now_command;
 pub mod project_command;
 pub mod prompt_command;
+pub mod rustdoc_command;
 pub mod search_command;
 pub mod tabs_command;
 pub mod term_command;
@@ -170,7 +170,7 @@ impl SlashCommandCompletionProvider {
                    .await?
                    .into_iter()
                    .map(|command_argument| {
-                        let confirm = if command_argument.run_command {
+                        let confirm =
                            editor
                                .clone()
                                .zip(workspace.clone())
@@ -178,7 +178,7 @@ impl SlashCommandCompletionProvider {
                                    Arc::new({
                                        let command_range = command_range.clone();
                                        let command_name = command_name.clone();
-                                        let command_argument = command_argument.new_text.clone();
+                                        let command_argument = command_argument.clone();
                                        move |cx: &mut WindowContext| {
                                            editor
                                                .update(cx, |editor, cx| {
@@ -194,24 +194,15 @@ impl SlashCommandCompletionProvider {
                                                .ok();
                                        }
                                    }) as Arc<_>
-                                })
-                        } else {
-                            None
-                        };
-
-                        let mut new_text = command_argument.new_text.clone();
-                        if !command_argument.run_command {
-                            new_text.push(' ');
-                        }
-
+                                });
                        project::Completion {
                            old_range: argument_range.clone(),
-                            label: CodeLabel::plain(command_argument.label, None),
-                            new_text,
+                            label: CodeLabel::plain(command_argument.clone(), None),
+                            new_text: command_argument.clone(),
                            documentation: None,
                            server_id: LanguageServerId(0),
                            lsp_completion: Default::default(),
-                            show_new_completions_on_confirm: !command_argument.run_command,
+                            show_new_completions_on_confirm: false,
                            confirm,
                        }
                    })
--- a/crates/assistant/src/slash_command/active_command.rs
+++ b/crates/assistant/src/slash_command/active_command.rs
@@ -4,7 +4,6 @@ use super::{
    SlashCommand, SlashCommandOutput,
 };
 use anyhow::{anyhow, Result};
-use assistant_slash_command::ArgumentCompletion;
 use editor::Editor;
 use gpui::{AppContext, Task, WeakView};
 use language::LspAdapterDelegate;
@@ -34,7 +33,7 @@ impl SlashCommand for ActiveSlashCommand {
        _cancel: Arc<AtomicBool>,
        _workspace: Option<WeakView<Workspace>>,
        _cx: &mut AppContext,
-    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+    ) -> Task<Result<Vec<String>>> {
        Task::ready(Err(anyhow!("this command does not require argument")))
    }

--- a/crates/assistant/src/slash_command/default_command.rs
+++ b/crates/assistant/src/slash_command/default_command.rs
@@ -1,7 +1,7 @@
 use super::{SlashCommand, SlashCommandOutput};
 use crate::prompt_library::PromptStore;
 use anyhow::{anyhow, Result};
-use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
+use assistant_slash_command::SlashCommandOutputSection;
 use gpui::{AppContext, Task, WeakView};
 use language::LspAdapterDelegate;
 use std::{
@@ -36,7 +36,7 @@ impl SlashCommand for DefaultSlashCommand {
        _cancellation_flag: Arc<AtomicBool>,
        _workspace: Option<WeakView<Workspace>>,
        _cx: &mut AppContext,
-    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+    ) -> Task<Result<Vec<String>>> {
        Task::ready(Err(anyhow!("this command does not require argument")))
    }

--- a/crates/assistant/src/slash_command/diagnostics_command.rs
+++ b/crates/assistant/src/slash_command/diagnostics_command.rs
@@ -1,6 +1,6 @@
 use super::{create_label_for_command, SlashCommand, SlashCommandOutput};
 use anyhow::{anyhow, Result};
-use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
+use assistant_slash_command::SlashCommandOutputSection;
 use fuzzy::{PathMatch, StringMatchCandidate};
 use gpui::{AppContext, Model, Task, View, WeakView};
 use language::{
@@ -20,9 +20,9 @@ use util::paths::PathMatcher;
 use util::ResultExt;
 use workspace::Workspace;

-pub(crate) struct DiagnosticsSlashCommand;
+pub(crate) struct DiagnosticsCommand;

-impl DiagnosticsSlashCommand {
+impl DiagnosticsCommand {
    fn search_paths(
        &self,
        query: String,
@@ -81,7 +81,7 @@ impl DiagnosticsSlashCommand {
    }
 }

-impl SlashCommand for DiagnosticsSlashCommand {
+impl SlashCommand for DiagnosticsCommand {
    fn name(&self) -> String {
        "diagnostics".into()
    }
@@ -108,7 +108,7 @@ impl SlashCommand for DiagnosticsSlashCommand {
        cancellation_flag: Arc<AtomicBool>,
        workspace: Option<WeakView<Workspace>>,
        cx: &mut AppContext,
-    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+    ) -> Task<Result<Vec<String>>> {
        let Some(workspace) = workspace.and_then(|workspace| workspace.upgrade()) else {
            return Task::ready(Err(anyhow!("workspace was dropped")));
        };
@@ -143,14 +143,7 @@ impl SlashCommand for DiagnosticsSlashCommand {
                .map(|candidate| candidate.string),
            );

-            Ok(matches
-                .into_iter()
-                .map(|completion| ArgumentCompletion {
-                    label: completion.clone(),
-                    new_text: completion,
-                    run_command: true,
-                })
-                .collect())
+            Ok(matches)
        })
    }

--- a/crates/assistant/src/slash_command/docs_command.rs
+++ b/crates/assistant/src/slash_command/docs_command.rs
@@ -1,373 +0,0 @@
-use std::path::Path;
-use std::sync::atomic::AtomicBool;
-use std::sync::Arc;
-
-use anyhow::{anyhow, bail, Result};
-use assistant_slash_command::{
-    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-};
-use gpui::{AppContext, Model, Task, WeakView};
-use indexed_docs::{
-    IndexedDocsRegistry, IndexedDocsStore, LocalProvider, PackageName, ProviderId, RustdocIndexer,
-};
-use language::LspAdapterDelegate;
-use project::{Project, ProjectPath};
-use ui::prelude::*;
-use util::{maybe, ResultExt};
-use workspace::Workspace;
-
-pub(crate) struct DocsSlashCommand;
-
-impl DocsSlashCommand {
-    pub const NAME: &'static str = "docs";
-
-    fn path_to_cargo_toml(project: Model<Project>, cx: &mut AppContext) -> Option<Arc<Path>> {
-        let worktree = project.read(cx).worktrees().next()?;
-        let worktree = worktree.read(cx);
-        let entry = worktree.entry_for_path("Cargo.toml")?;
-        let path = ProjectPath {
-            worktree_id: worktree.id(),
-            path: entry.path.clone(),
-        };
-        Some(Arc::from(
-            project.read(cx).absolute_path(&path, cx)?.as_path(),
-        ))
-    }
-
-    /// Ensures that the rustdoc provider is registered.
-    ///
-    /// Ideally we would do this sooner, but we need to wait until we're able to
-    /// access the workspace so we can read the project.
-    fn ensure_rustdoc_provider_is_registered(
-        &self,
-        workspace: Option<WeakView<Workspace>>,
-        cx: &mut AppContext,
-    ) {
-        let indexed_docs_registry = IndexedDocsRegistry::global(cx);
-        if indexed_docs_registry
-            .get_provider_store(ProviderId::rustdoc())
-            .is_none()
-        {
-            let index_provider_deps = maybe!({
-                let workspace = workspace.ok_or_else(|| anyhow!("no workspace"))?;
-                let workspace = workspace
-                    .upgrade()
-                    .ok_or_else(|| anyhow!("workspace was dropped"))?;
-                let project = workspace.read(cx).project().clone();
-                let fs = project.read(cx).fs().clone();
-                let cargo_workspace_root = Self::path_to_cargo_toml(project, cx)
-                    .and_then(|path| path.parent().map(|path| path.to_path_buf()))
-                    .ok_or_else(|| anyhow!("no Cargo workspace root found"))?;
-
-                anyhow::Ok((fs, cargo_workspace_root))
-            });
-
-            if let Some((fs, cargo_workspace_root)) = index_provider_deps.log_err() {
-                indexed_docs_registry.register_provider(Box::new(RustdocIndexer::new(Box::new(
-                    LocalProvider::new(fs, cargo_workspace_root),
-                ))));
-            }
-        }
-    }
-}
-
-impl SlashCommand for DocsSlashCommand {
-    fn name(&self) -> String {
-        Self::NAME.into()
-    }
-
-    fn description(&self) -> String {
-        "insert docs".into()
-    }
-
-    fn menu_text(&self) -> String {
-        "Insert Documentation".into()
-    }
-
-    fn requires_argument(&self) -> bool {
-        true
-    }
-
-    fn complete_argument(
-        self: Arc<Self>,
-        query: String,
-        _cancel: Arc<AtomicBool>,
-        workspace: Option<WeakView<Workspace>>,
-        cx: &mut AppContext,
-    ) -> Task<Result<Vec<ArgumentCompletion>>> {
-        self.ensure_rustdoc_provider_is_registered(workspace, cx);
-
-        let indexed_docs_registry = IndexedDocsRegistry::global(cx);
-        let args = DocsSlashCommandArgs::parse(&query);
-        let store = args
-            .provider()
-            .ok_or_else(|| anyhow!("no docs provider specified"))
-            .and_then(|provider| IndexedDocsStore::try_global(provider, cx));
-        cx.background_executor().spawn(async move {
-            fn build_completions(
-                provider: ProviderId,
-                items: Vec<String>,
-            ) -> Vec<ArgumentCompletion> {
-                items
-                    .into_iter()
-                    .map(|item| ArgumentCompletion {
-                        label: item.clone(),
-                        new_text: format!("{provider} {item}"),
-                        run_command: true,
-                    })
-                    .collect()
-            }
-
-            match args {
-                DocsSlashCommandArgs::NoProvider => {
-                    let providers = indexed_docs_registry.list_providers();
-                    Ok(providers
-                        .into_iter()
-                        .map(|provider| ArgumentCompletion {
-                            label: provider.to_string(),
-                            new_text: provider.to_string(),
-                            run_command: false,
-                        })
-                        .collect())
-                }
-                DocsSlashCommandArgs::SearchPackageDocs {
-                    provider,
-                    package,
-                    index,
-                } => {
-                    let store = store?;
-
-                    if index {
-                        // We don't need to hold onto this task, as the `IndexedDocsStore` will hold it
-                        // until it completes.
-                        let _ = store.clone().index(package.as_str().into());
-                    }
-
-                    let items = store.search(package).await;
-                    Ok(build_completions(provider, items))
-                }
-                DocsSlashCommandArgs::SearchItemDocs {
-                    provider,
-                    item_path,
-                    ..
-                } => {
-                    let store = store?;
-                    let items = store.search(item_path).await;
-                    Ok(build_completions(provider, items))
-                }
-            }
-        })
-    }
-
-    fn run(
-        self: Arc<Self>,
-        argument: Option<&str>,
-        _workspace: WeakView<Workspace>,
-        _delegate: Arc<dyn LspAdapterDelegate>,
-        cx: &mut WindowContext,
-    ) -> Task<Result<SlashCommandOutput>> {
-        let Some(argument) = argument else {
-            return Task::ready(Err(anyhow!("missing argument")));
-        };
-
-        let args = DocsSlashCommandArgs::parse(argument);
-        let text = cx.background_executor().spawn({
-            let store = args
-                .provider()
-                .ok_or_else(|| anyhow!("no docs provider specified"))
-                .and_then(|provider| IndexedDocsStore::try_global(provider, cx));
-            async move {
-                match args {
-                    DocsSlashCommandArgs::NoProvider => bail!("no docs provider specified"),
-                    DocsSlashCommandArgs::SearchPackageDocs {
-                        provider, package, ..
-                    } => {
-                        let store = store?;
-                        let item_docs = store.load(package.clone()).await?;
-
-                        anyhow::Ok((provider, package, item_docs.to_string()))
-                    }
-                    DocsSlashCommandArgs::SearchItemDocs {
-                        provider,
-                        item_path,
-                        ..
-                    } => {
-                        let store = store?;
-                        let item_docs = store.load(item_path.clone()).await?;
-
-                        anyhow::Ok((provider, item_path, item_docs.to_string()))
-                    }
-                }
-            }
-        });
-
-        cx.foreground_executor().spawn(async move {
-            let (provider, path, text) = text.await?;
-            let range = 0..text.len();
-            Ok(SlashCommandOutput {
-                text,
-                sections: vec![SlashCommandOutputSection {
-                    range,
-                    icon: IconName::FileRust,
-                    label: format!("docs ({provider}): {path}",).into(),
-                }],
-                run_commands_in_text: false,
-            })
-        })
-    }
-}
-
-fn is_item_path_delimiter(char: char) -> bool {
-    !char.is_alphanumeric() && char != '-' && char != '_'
-}
-
-#[derive(Debug, PartialEq)]
-pub(crate) enum DocsSlashCommandArgs {
-    NoProvider,
-    SearchPackageDocs {
-        provider: ProviderId,
-        package: String,
-        index: bool,
-    },
-    SearchItemDocs {
-        provider: ProviderId,
-        package: String,
-        item_path: String,
-    },
-}
-
-impl DocsSlashCommandArgs {
-    pub fn parse(argument: &str) -> Self {
-        let Some((provider, argument)) = argument.split_once(' ') else {
-            return Self::NoProvider;
-        };
-
-        let provider = ProviderId(provider.into());
-
-        if let Some((package, rest)) = argument.split_once(is_item_path_delimiter) {
-            if rest.trim().is_empty() {
-                Self::SearchPackageDocs {
-                    provider,
-                    package: package.to_owned(),
-                    index: true,
-                }
-            } else {
-                Self::SearchItemDocs {
-                    provider,
-                    package: package.to_owned(),
-                    item_path: argument.to_owned(),
-                }
-            }
-        } else {
-            Self::SearchPackageDocs {
-                provider,
-                package: argument.to_owned(),
-                index: false,
-            }
-        }
-    }
-
-    pub fn provider(&self) -> Option<ProviderId> {
-        match self {
-            Self::NoProvider => None,
-            Self::SearchPackageDocs { provider, .. } | Self::SearchItemDocs { provider, .. } => {
-                Some(provider.clone())
-            }
-        }
-    }
-
-    pub fn package(&self) -> Option<PackageName> {
-        match self {
-            Self::NoProvider => None,
-            Self::SearchPackageDocs { package, .. } | Self::SearchItemDocs { package, .. } => {
-                Some(package.as_str().into())
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse_docs_slash_command_args() {
-        assert_eq!(
-            DocsSlashCommandArgs::parse(""),
-            DocsSlashCommandArgs::NoProvider
-        );
-        assert_eq!(
-            DocsSlashCommandArgs::parse("rustdoc"),
-            DocsSlashCommandArgs::NoProvider
-        );
-
-        assert_eq!(
-            DocsSlashCommandArgs::parse("rustdoc "),
-            DocsSlashCommandArgs::SearchPackageDocs {
-                provider: ProviderId("rustdoc".into()),
-                package: "".into(),
-                index: false
-            }
-        );
-        assert_eq!(
-            DocsSlashCommandArgs::parse("gleam "),
-            DocsSlashCommandArgs::SearchPackageDocs {
-                provider: ProviderId("gleam".into()),
-                package: "".into(),
-                index: false
-            }
-        );
-
-        assert_eq!(
-            DocsSlashCommandArgs::parse("rustdoc gpui"),
-            DocsSlashCommandArgs::SearchPackageDocs {
-                provider: ProviderId("rustdoc".into()),
-                package: "gpui".into(),
-                index: false,
-            }
-        );
-        assert_eq!(
-            DocsSlashCommandArgs::parse("gleam gleam_stdlib"),
-            DocsSlashCommandArgs::SearchPackageDocs {
-                provider: ProviderId("gleam".into()),
-                package: "gleam_stdlib".into(),
-                index: false
-            }
-        );
-
-        // Adding an item path delimiter indicates we can start indexing.
-        assert_eq!(
-            DocsSlashCommandArgs::parse("rustdoc gpui:"),
-            DocsSlashCommandArgs::SearchPackageDocs {
-                provider: ProviderId("rustdoc".into()),
-                package: "gpui".into(),
-                index: true,
-            }
-        );
-        assert_eq!(
-            DocsSlashCommandArgs::parse("gleam gleam_stdlib/"),
-            DocsSlashCommandArgs::SearchPackageDocs {
-                provider: ProviderId("gleam".into()),
-                package: "gleam_stdlib".into(),
-                index: true
-            }
-        );
-
-        assert_eq!(
-            DocsSlashCommandArgs::parse("rustdoc gpui::foo::bar::Baz"),
-            DocsSlashCommandArgs::SearchItemDocs {
-                provider: ProviderId("rustdoc".into()),
-                package: "gpui".into(),
-                item_path: "gpui::foo::bar::Baz".into()
-            }
-        );
-        assert_eq!(
-            DocsSlashCommandArgs::parse("gleam gleam_stdlib/gleam/int"),
-            DocsSlashCommandArgs::SearchItemDocs {
-                provider: ProviderId("gleam".into()),
-                package: "gleam_stdlib".into(),
-                item_path: "gleam_stdlib/gleam/int".into()
-            }
-        );
-    }
-}
--- a/crates/assistant/src/slash_command/fetch_command.rs
+++ b/crates/assistant/src/slash_command/fetch_command.rs
@@ -4,9 +4,7 @@ use std::sync::atomic::AtomicBool;
 use std::sync::Arc;

 use anyhow::{anyhow, bail, Context, Result};
-use assistant_slash_command::{
-    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-};
+use assistant_slash_command::{SlashCommand, SlashCommandOutput, SlashCommandOutputSection};
 use futures::AsyncReadExt;
 use gpui::{AppContext, Task, WeakView};
 use html_to_markdown::{convert_html_to_markdown, markdown, TagHandler};
@@ -121,7 +119,7 @@ impl SlashCommand for FetchSlashCommand {
        _cancel: Arc<AtomicBool>,
        _workspace: Option<WeakView<Workspace>>,
        _cx: &mut AppContext,
-    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+    ) -> Task<Result<Vec<String>>> {
        Task::ready(Ok(Vec::new()))
    }

--- a/crates/assistant/src/slash_command/file_command.rs
+++ b/crates/assistant/src/slash_command/file_command.rs
@@ -1,6 +1,6 @@
 use super::{diagnostics_command::write_single_file_diagnostics, SlashCommand, SlashCommandOutput};
 use anyhow::{anyhow, Result};
-use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
+use assistant_slash_command::SlashCommandOutputSection;
 use fuzzy::PathMatch;
 use gpui::{AppContext, Model, Task, View, WeakView};
 use language::{BufferSnapshot, LineEnding, LspAdapterDelegate};
@@ -105,7 +105,7 @@ impl SlashCommand for FileSlashCommand {
        cancellation_flag: Arc<AtomicBool>,
        workspace: Option<WeakView<Workspace>>,
        cx: &mut AppContext,
-    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+    ) -> Task<Result<Vec<String>>> {
        let Some(workspace) = workspace.and_then(|workspace| workspace.upgrade()) else {
            return Task::ready(Err(anyhow!("workspace was dropped")));
        };
@@ -116,17 +116,11 @@ impl SlashCommand for FileSlashCommand {
                .await
                .into_iter()
                .map(|path_match| {
-                    let text = format!(
+                    format!(
                        "{}{}",
                        path_match.path_prefix,
                        path_match.path.to_string_lossy()
-                    );
-
-                    ArgumentCompletion {
-                        label: text.clone(),
-                        new_text: text,
-                        run_command: true,
-                    }
+                    )
                })
                .collect())
        })
--- a/crates/assistant/src/slash_command/now_command.rs
+++ b/crates/assistant/src/slash_command/now_command.rs
@@ -2,13 +2,11 @@ use std::sync::atomic::AtomicBool;
 use std::sync::Arc;

 use anyhow::Result;
-use assistant_slash_command::{
-    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-};
-use chrono::Local;
+use assistant_slash_command::{SlashCommand, SlashCommandOutput, SlashCommandOutputSection};
+use chrono::{DateTime, Local};
 use gpui::{AppContext, Task, WeakView};
 use language::LspAdapterDelegate;
-use ui::prelude::*;
+use ui::{prelude::*, ButtonLike, ElevationIndex};
 use workspace::Workspace;

 pub(crate) struct NowSlashCommand;
@@ -36,7 +34,7 @@ impl SlashCommand for NowSlashCommand {
        _cancel: Arc<AtomicBool>,
        _workspace: Option<WeakView<Workspace>>,
        _cx: &mut AppContext,
-    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+    ) -> Task<Result<Vec<String>>> {
        Task::ready(Ok(Vec::new()))
    }

@@ -48,7 +46,7 @@ impl SlashCommand for NowSlashCommand {
        _cx: &mut WindowContext,
    ) -> Task<Result<SlashCommandOutput>> {
        let now = Local::now();
-        let text = format!("Today is {now}.", now = now.to_rfc2822());
+        let text = format!("Today is {now}.", now = now.to_rfc3339());
        let range = 0..text.len();

        Task::ready(Ok(SlashCommandOutput {
@@ -56,9 +54,29 @@ impl SlashCommand for NowSlashCommand {
            sections: vec![SlashCommandOutputSection {
                range,
                icon: IconName::CountdownTimer,
-                label: now.to_rfc2822().into(),
+                label: now.to_rfc3339().into(),
            }],
            run_commands_in_text: false,
        }))
    }
 }
+
+#[derive(IntoElement)]
+struct NowPlaceholder {
+    pub id: ElementId,
+    pub unfold: Arc<dyn Fn(&mut WindowContext)>,
+    pub now: DateTime<Local>,
+}
+
+impl RenderOnce for NowPlaceholder {
+    fn render(self, _cx: &mut WindowContext) -> impl IntoElement {
+        let unfold = self.unfold;
+
+        ButtonLike::new(self.id)
+            .style(ButtonStyle::Filled)
+            .layer(ElevationIndex::ElevatedSurface)
+            .child(Icon::new(IconName::CountdownTimer))
+            .child(Label::new(self.now.to_rfc3339()))
+            .on_click(move |_, cx| unfold(cx))
+    }
+}
--- a/crates/assistant/src/slash_command/project_command.rs
+++ b/crates/assistant/src/slash_command/project_command.rs
@@ -1,6 +1,6 @@
 use super::{SlashCommand, SlashCommandOutput};
 use anyhow::{anyhow, Context, Result};
-use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
+use assistant_slash_command::SlashCommandOutputSection;
 use fs::Fs;
 use gpui::{AppContext, Model, Task, WeakView};
 use language::LspAdapterDelegate;
@@ -107,7 +107,7 @@ impl SlashCommand for ProjectSlashCommand {
        _cancel: Arc<AtomicBool>,
        _workspace: Option<WeakView<Workspace>>,
        _cx: &mut AppContext,
-    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+    ) -> Task<Result<Vec<String>>> {
        Task::ready(Err(anyhow!("this command does not require argument")))
    }

--- a/crates/assistant/src/slash_command/prompt_command.rs
+++ b/crates/assistant/src/slash_command/prompt_command.rs
@@ -1,7 +1,7 @@
 use super::{SlashCommand, SlashCommandOutput};
 use crate::prompt_library::PromptStore;
 use anyhow::{anyhow, Context, Result};
-use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
+use assistant_slash_command::SlashCommandOutputSection;
 use gpui::{AppContext, Task, WeakView};
 use language::LspAdapterDelegate;
 use std::sync::{atomic::AtomicBool, Arc};
@@ -33,20 +33,13 @@ impl SlashCommand for PromptSlashCommand {
        _cancellation_flag: Arc<AtomicBool>,
        _workspace: Option<WeakView<Workspace>>,
        cx: &mut AppContext,
-    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+    ) -> Task<Result<Vec<String>>> {
        let store = PromptStore::global(cx);
        cx.background_executor().spawn(async move {
            let prompts = store.await?.search(query).await;
            Ok(prompts
                .into_iter()
-                .filter_map(|prompt| {
-                    let prompt_title = prompt.title?.to_string();
-                    Some(ArgumentCompletion {
-                        label: prompt_title.clone(),
-                        new_text: prompt_title,
-                        run_command: true,
-                    })
-                })
+                .filter_map(|prompt| Some(prompt.title?.to_string()))
                .collect())
        })
    }
--- a/crates/assistant/src/slash_command/rustdoc_command.rs
+++ b/crates/assistant/src/slash_command/rustdoc_command.rs
@@ -0,0 +1,240 @@
+use std::path::Path;
+use std::sync::atomic::AtomicBool;
+use std::sync::Arc;
+
+use anyhow::{anyhow, bail, Context, Result};
+use assistant_slash_command::{SlashCommand, SlashCommandOutput, SlashCommandOutputSection};
+use fs::Fs;
+use futures::AsyncReadExt;
+use gpui::{AppContext, Model, Task, WeakView};
+use http::{AsyncBody, HttpClient, HttpClientWithUrl};
+use language::LspAdapterDelegate;
+use project::{Project, ProjectPath};
+use rustdoc::{convert_rustdoc_to_markdown, CrateName, LocalProvider, RustdocSource, RustdocStore};
+use ui::prelude::*;
+use util::{maybe, ResultExt};
+use workspace::Workspace;
+
+pub(crate) struct RustdocSlashCommand;
+
+impl RustdocSlashCommand {
+    async fn build_message(
+        fs: Arc<dyn Fs>,
+        http_client: Arc<HttpClientWithUrl>,
+        crate_name: CrateName,
+        module_path: Vec<String>,
+        path_to_cargo_toml: Option<&Path>,
+    ) -> Result<(RustdocSource, String)> {
+        let cargo_workspace_root = path_to_cargo_toml.and_then(|path| path.parent());
+        if let Some(cargo_workspace_root) = cargo_workspace_root {
+            let mut local_cargo_doc_path = cargo_workspace_root.join("target/doc");
+            local_cargo_doc_path.push(crate_name.as_ref());
+            if !module_path.is_empty() {
+                local_cargo_doc_path.push(module_path.join("/"));
+            }
+            local_cargo_doc_path.push("index.html");
+
+            if let Ok(contents) = fs.load(&local_cargo_doc_path).await {
+                let (markdown, _items) = convert_rustdoc_to_markdown(contents.as_bytes())?;
+
+                dbg!(_items);
+
+                return Ok((RustdocSource::Local, markdown));
+            }
+        }
+
+        let version = "latest";
+        let path = format!(
+            "{crate_name}/{version}/{crate_name}/{module_path}",
+            module_path = module_path.join("/")
+        );
+
+        let mut response = http_client
+            .get(
+                &format!("https://docs.rs/{path}"),
+                AsyncBody::default(),
+                true,
+            )
+            .await?;
+
+        let mut body = Vec::new();
+        response
+            .body_mut()
+            .read_to_end(&mut body)
+            .await
+            .context("error reading docs.rs response body")?;
+
+        if response.status().is_client_error() {
+            let text = String::from_utf8_lossy(body.as_slice());
+            bail!(
+                "status error {}, response: {text:?}",
+                response.status().as_u16()
+            );
+        }
+
+        let (markdown, _items) = convert_rustdoc_to_markdown(&body[..])?;
+
+        Ok((RustdocSource::DocsDotRs, markdown))
+    }
+
+    fn path_to_cargo_toml(project: Model<Project>, cx: &mut AppContext) -> Option<Arc<Path>> {
+        let worktree = project.read(cx).worktrees().next()?;
+        let worktree = worktree.read(cx);
+        let entry = worktree.entry_for_path("Cargo.toml")?;
+        let path = ProjectPath {
+            worktree_id: worktree.id(),
+            path: entry.path.clone(),
+        };
+        Some(Arc::from(
+            project.read(cx).absolute_path(&path, cx)?.as_path(),
+        ))
+    }
+}
+
+impl SlashCommand for RustdocSlashCommand {
+    fn name(&self) -> String {
+        "rustdoc".into()
+    }
+
+    fn description(&self) -> String {
+        "insert Rust docs".into()
+    }
+
+    fn menu_text(&self) -> String {
+        "Insert Rust Documentation".into()
+    }
+
+    fn requires_argument(&self) -> bool {
+        true
+    }
+
+    fn complete_argument(
+        self: Arc<Self>,
+        query: String,
+        _cancel: Arc<AtomicBool>,
+        workspace: Option<WeakView<Workspace>>,
+        cx: &mut AppContext,
+    ) -> Task<Result<Vec<String>>> {
+        let index_provider_deps = maybe!({
+            let workspace = workspace.ok_or_else(|| anyhow!("no workspace"))?;
+            let workspace = workspace
+                .upgrade()
+                .ok_or_else(|| anyhow!("workspace was dropped"))?;
+            let project = workspace.read(cx).project().clone();
+            let fs = project.read(cx).fs().clone();
+            let cargo_workspace_root = Self::path_to_cargo_toml(project, cx)
+                .and_then(|path| path.parent().map(|path| path.to_path_buf()))
+                .ok_or_else(|| anyhow!("no Cargo workspace root found"))?;
+
+            anyhow::Ok((fs, cargo_workspace_root))
+        });
+
+        let store = RustdocStore::global(cx);
+        cx.background_executor().spawn(async move {
+            if let Some((crate_name, rest)) = query.split_once(':') {
+                if rest.is_empty() {
+                    if let Some((fs, cargo_workspace_root)) = index_provider_deps.log_err() {
+                        let provider = Box::new(LocalProvider::new(fs, cargo_workspace_root));
+                        // We don't need to hold onto this task, as the `RustdocStore` will hold it
+                        // until it completes.
+                        let _ = store.clone().index(crate_name.into(), provider);
+                    }
+                }
+            }
+
+            let items = store.search(query).await;
+            Ok(items)
+        })
+    }
+
+    fn run(
+        self: Arc<Self>,
+        argument: Option<&str>,
+        workspace: WeakView<Workspace>,
+        _delegate: Arc<dyn LspAdapterDelegate>,
+        cx: &mut WindowContext,
+    ) -> Task<Result<SlashCommandOutput>> {
+        let Some(argument) = argument else {
+            return Task::ready(Err(anyhow!("missing crate name")));
+        };
+        let Some(workspace) = workspace.upgrade() else {
+            return Task::ready(Err(anyhow!("workspace was dropped")));
+        };
+
+        let project = workspace.read(cx).project().clone();
+        let fs = project.read(cx).fs().clone();
+        let http_client = workspace.read(cx).client().http_client();
+        let path_to_cargo_toml = Self::path_to_cargo_toml(project, cx);
+
+        let mut path_components = argument.split("::");
+        let crate_name = match path_components
+            .next()
+            .ok_or_else(|| anyhow!("missing crate name"))
+        {
+            Ok(crate_name) => CrateName::from(crate_name),
+            Err(err) => return Task::ready(Err(err)),
+        };
+        let item_path = path_components.map(ToString::to_string).collect::<Vec<_>>();
+
+        let text = cx.background_executor().spawn({
+            let rustdoc_store = RustdocStore::global(cx);
+            let crate_name = crate_name.clone();
+            let item_path = item_path.clone();
+            async move {
+                let item_docs = rustdoc_store
+                    .load(
+                        crate_name.clone(),
+                        if item_path.is_empty() {
+                            None
+                        } else {
+                            Some(item_path.join("::"))
+                        },
+                    )
+                    .await;
+
+                if let Ok(item_docs) = item_docs {
+                    anyhow::Ok((RustdocSource::Index, item_docs.docs().to_owned()))
+                } else {
+                    Self::build_message(
+                        fs,
+                        http_client,
+                        crate_name,
+                        item_path,
+                        path_to_cargo_toml.as_deref(),
+                    )
+                    .await
+                }
+            }
+        });
+
+        let module_path = if item_path.is_empty() {
+            None
+        } else {
+            Some(SharedString::from(item_path.join("::")))
+        };
+        cx.foreground_executor().spawn(async move {
+            let (source, text) = text.await?;
+            let range = 0..text.len();
+            let crate_path = module_path
+                .map(|module_path| format!("{}::{}", crate_name, module_path))
+                .unwrap_or_else(|| crate_name.to_string());
+            Ok(SlashCommandOutput {
+                text,
+                sections: vec![SlashCommandOutputSection {
+                    range,
+                    icon: IconName::FileRust,
+                    label: format!(
+                        "rustdoc ({source}): {crate_path}",
+                        source = match source {
+                            RustdocSource::Index => "index",
+                            RustdocSource::Local => "local",
+                            RustdocSource::DocsDotRs => "docs.rs",
+                        }
+                    )
+                    .into(),
+                }],
+                run_commands_in_text: false,
+            })
+        })
+    }
+}
--- a/crates/assistant/src/slash_command/search_command.rs
+++ b/crates/assistant/src/slash_command/search_command.rs
@@ -4,7 +4,7 @@ use super::{
    SlashCommand, SlashCommandOutput,
 };
 use anyhow::Result;
-use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
+use assistant_slash_command::SlashCommandOutputSection;
 use gpui::{AppContext, Task, WeakView};
 use language::{CodeLabel, LineEnding, LspAdapterDelegate};
 use semantic_index::SemanticIndex;
@@ -46,7 +46,7 @@ impl SlashCommand for SearchSlashCommand {
        _cancel: Arc<AtomicBool>,
        _workspace: Option<WeakView<Workspace>>,
        _cx: &mut AppContext,
-    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+    ) -> Task<Result<Vec<String>>> {
        Task::ready(Ok(Vec::new()))
    }

--- a/crates/assistant/src/slash_command/tabs_command.rs
+++ b/crates/assistant/src/slash_command/tabs_command.rs
@@ -4,7 +4,6 @@ use super::{
    SlashCommand, SlashCommandOutput,
 };
 use anyhow::{anyhow, Result};
-use assistant_slash_command::ArgumentCompletion;
 use collections::HashMap;
 use editor::Editor;
 use gpui::{AppContext, Entity, Task, WeakView};
@@ -38,7 +37,7 @@ impl SlashCommand for TabsSlashCommand {
        _cancel: Arc<std::sync::atomic::AtomicBool>,
        _workspace: Option<WeakView<Workspace>>,
        _cx: &mut AppContext,
-    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+    ) -> Task<Result<Vec<String>>> {
        Task::ready(Err(anyhow!("this command does not require argument")))
    }

--- a/crates/assistant/src/slash_command/term_command.rs
+++ b/crates/assistant/src/slash_command/term_command.rs
@@ -2,9 +2,7 @@ use std::sync::atomic::AtomicBool;
 use std::sync::Arc;

 use anyhow::Result;
-use assistant_slash_command::{
-    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-};
+use assistant_slash_command::{SlashCommand, SlashCommandOutput, SlashCommandOutputSection};
 use gpui::{AppContext, Task, WeakView};
 use language::{CodeLabel, LspAdapterDelegate};
 use terminal_view::{terminal_panel::TerminalPanel, TerminalView};
@@ -44,12 +42,8 @@ impl SlashCommand for TermSlashCommand {
        _cancel: Arc<AtomicBool>,
        _workspace: Option<WeakView<Workspace>>,
        _cx: &mut AppContext,
-    ) -> Task<Result<Vec<ArgumentCompletion>>> {
-        Task::ready(Ok(vec![ArgumentCompletion {
-            label: LINE_COUNT_ARG.to_string(),
-            new_text: LINE_COUNT_ARG.to_string(),
-            run_command: true,
-        }]))
+    ) -> Task<Result<Vec<String>>> {
+        Task::ready(Ok(vec![LINE_COUNT_ARG.to_string()]))
    }

    fn run(
--- a/crates/assistant/src/terminal_inline_assistant.rs
+++ b/crates/assistant/src/terminal_inline_assistant.rs
--- a/crates/assistant_slash_command/src/assistant_slash_command.rs
+++ b/crates/assistant_slash_command/src/assistant_slash_command.rs
@@ -15,16 +15,6 @@ pub fn init(cx: &mut AppContext) {
    SlashCommandRegistry::default_global(cx);
 }

-#[derive(Debug)]
-pub struct ArgumentCompletion {
-    /// The label to display for this completion.
-    pub label: String,
-    /// The new text that should be inserted into the command when this completion is accepted.
-    pub new_text: String,
-    /// Whether the command should be run when accepting this completion.
-    pub run_command: bool,
-}
-
 pub trait SlashCommand: 'static + Send + Sync {
    fn name(&self) -> String;
    fn label(&self, _cx: &AppContext) -> CodeLabel {
@@ -38,7 +28,7 @@ pub trait SlashCommand: 'static + Send + Sync {
        cancel: Arc<AtomicBool>,
        workspace: Option<WeakView<Workspace>>,
        cx: &mut AppContext,
-    ) -> Task<Result<Vec<ArgumentCompletion>>>;
+    ) -> Task<Result<Vec<String>>>;
    fn requires_argument(&self) -> bool;
    fn run(
        self: Arc<Self>,
--- a/crates/cli/src/main.rs
+++ b/crates/cli/src/main.rs
@@ -196,24 +196,23 @@ mod linux {
    impl Detect {
        pub fn detect(path: Option<&Path>) -> anyhow::Result<impl InstalledApp> {
            let path = if let Some(path) = path {
-                path.to_path_buf().canonicalize()?
+                path.to_path_buf().canonicalize()
            } else {
                let cli = env::current_exe()?;
                let dir = cli
                    .parent()
+                    .and_then(Path::parent)
                    .ok_or_else(|| anyhow!("no parent path for cli"))?;

-                // libexec is the standard, lib/zed is for Arch (and other non-libexec distros),
-                // ./zed is for the target directory in development builds.
-                let possible_locations =
-                    ["../libexec/zed-editor", "../lib/zed/zed-editor", "./zed"];
-                possible_locations
-                    .iter()
-                    .find_map(|p| dir.join(p).canonicalize().ok().filter(|path| path != &cli))
-                    .ok_or_else(|| {
-                        anyhow!("could not find any of: {}", possible_locations.join(", "))
-                    })?
-            };
+                match dir.join("libexec").join("zed-editor").canonicalize() {
+                    Ok(path) => Ok(path),
+                    // In development cli and zed are in the ./target/ directory together
+                    Err(e) => match cli.parent().unwrap().join("zed").canonicalize() {
+                        Ok(path) if path != cli => Ok(path),
+                        _ => Err(e),
+                    },
+                }
+            }?;

            Ok(App(path))
        }
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -202,10 +202,6 @@ impl Telemetry {
            event_coalescer: EventCoalescer::new(clock.clone()),
            max_queue_size: MAX_QUEUE_LEN,
            worktree_id_map: WorktreeIdMap(HashMap::from_iter([
-                (
-                    "pnpm-lock.yaml".to_string(),
-                    ProjectCache::new("pnpm".to_string()),
-                ),
                (
                    "yarn.lock".to_string(),
                    ProjectCache::new("yarn".to_string()),
@@ -615,7 +611,6 @@ impl Telemetry {

                        let request_body = EventRequestBody {
                            installation_id: state.installation_id.as_deref().map(Into::into),
-                            metrics_id: state.metrics_id.as_deref().map(Into::into),
                            session_id: state.session_id.clone(),
                            is_staff: state.is_staff,
                            app_version: state.app_version.clone(),
--- a/crates/clock/src/clock.rs
+++ b/crates/clock/src/clock.rs
@@ -87,27 +87,51 @@ impl Global {
    }

    pub fn observed_any(&self, other: &Self) -> bool {
-        self.0
-            .iter()
-            .zip(other.0.iter())
-            .any(|(left, right)| *right > 0 && left >= right)
+        let mut lhs = self.0.iter();
+        let mut rhs = other.0.iter();
+        loop {
+            if let Some(left) = lhs.next() {
+                if let Some(right) = rhs.next() {
+                    if *right > 0 && left >= right {
+                        return true;
+                    }
+                } else {
+                    return false;
+                }
+            } else {
+                return false;
+            }
+        }
    }

    pub fn observed_all(&self, other: &Self) -> bool {
+        let mut lhs = self.0.iter();
        let mut rhs = other.0.iter();
-        self.0.iter().all(|left| match rhs.next() {
-            Some(right) => left >= right,
-            None => true,
-        }) && rhs.next().is_none()
+        loop {
+            if let Some(left) = lhs.next() {
+                if let Some(right) = rhs.next() {
+                    if left < right {
+                        return false;
+                    }
+                } else {
+                    return true;
+                }
+            } else {
+                return rhs.next().is_none();
+            }
+        }
    }

    pub fn changed_since(&self, other: &Self) -> bool {
-        self.0.len() > other.0.len()
-            || self
-                .0
-                .iter()
-                .zip(other.0.iter())
-                .any(|(left, right)| left > right)
+        if self.0.len() > other.0.len() {
+            return true;
+        }
+        for (left, right) in self.0.iter().zip(other.0.iter()) {
+            if left > right {
+                return true;
+            }
+        }
+        false
    }

    pub fn iter(&self) -> impl Iterator<Item = Lamport> + '_ {
--- a/crates/collab/src/api/events.rs
+++ b/crates/collab/src/api/events.rs
@@ -664,7 +664,6 @@ where
 #[derive(Serialize, Debug, clickhouse::Row)]
 pub struct EditorEventRow {
    installation_id: String,
-    metrics_id: String,
    operation: String,
    app_version: String,
    file_extension: String,
@@ -714,7 +713,6 @@ impl EditorEventRow {
            os_version: body.os_version.clone().unwrap_or_default(),
            architecture: body.architecture.clone(),
            installation_id: body.installation_id.clone().unwrap_or_default(),
-            metrics_id: body.metrics_id.clone().unwrap_or_default(),
            session_id: body.session_id.clone(),
            is_staff: body.is_staff,
            time: time.timestamp_millis(),
--- a/crates/collab/src/api/extensions.rs
+++ b/crates/collab/src/api/extensions.rs
@@ -36,6 +36,8 @@ pub fn router() -> Router {
 struct GetExtensionsParams {
    filter: Option<String>,
    #[serde(default)]
+    ids: Option<String>,
+    #[serde(default)]
    max_schema_version: i32,
 }

@@ -43,15 +45,18 @@ async fn get_extensions(
    Extension(app): Extension<Arc<AppState>>,
    Query(params): Query<GetExtensionsParams>,
 ) -> Result<Json<GetExtensionsResponse>> {
-    let extensions = app
-        .db
-        .get_extensions(params.filter.as_deref(), params.max_schema_version, 500)
-        .await?;
+    let extension_ids = params
+        .ids
+        .as_ref()
+        .map(|s| s.split(',').map(|s| s.trim()).collect::<Vec<_>>());

-    if let Some(query) = params.filter.as_deref() {
-        let count = extensions.len();
-        tracing::info!(query, count, "extension_search")
-    }
+    let extensions = if let Some(extension_ids) = extension_ids {
+        app.db.get_extensions_by_ids(&extension_ids, None).await?
+    } else {
+        app.db
+            .get_extensions(params.filter.as_deref(), params.max_schema_version, 500)
+            .await?
+    };

    Ok(Json(GetExtensionsResponse { data: extensions }))
 }
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -2583,13 +2583,14 @@ async fn rejoin_dev_server_projects(
        )
        .await?
    };
+    notify_rejoined_projects(&mut rejoined_projects, &session)?;
+
    response.send(proto::RejoinRemoteProjectsResponse {
        rejoined_projects: rejoined_projects
-            .iter()
+            .into_iter()
            .map(|project| project.to_proto())
            .collect(),
-    })?;
-    notify_rejoined_projects(&mut rejoined_projects, &session)
+    })
 }

 async fn reconnect_dev_server(
@@ -4462,7 +4463,6 @@ async fn complete_with_open_ai(
                        tool_calls: choice
                            .delta
                            .tool_calls
-                            .unwrap_or_default()
                            .into_iter()
                            .map(|delta| proto::ToolCallDelta {
                                index: delta.index as u32,
--- a/crates/collab/src/rpc/connection_pool.rs
+++ b/crates/collab/src/rpc/connection_pool.rs
@@ -73,7 +73,6 @@ impl ConnectionPool {
    pub fn reset(&mut self) {
        self.connections.clear();
        self.connected_users.clear();
-        self.connected_dev_servers.clear();
        self.channels.clear();
    }

--- a/crates/collab/src/tests/dev_server_tests.rs
+++ b/crates/collab/src/tests/dev_server_tests.rs
@@ -504,29 +504,6 @@ async fn test_dev_server_reconnect(
        .unwrap();
 }

-#[gpui::test]
-async fn test_dev_server_restart(cx1: &mut gpui::TestAppContext, cx2: &mut gpui::TestAppContext) {
-    let (server, client1) = TestServer::start1(cx1).await;
-
-    let (_dev_server, remote_workspace) =
-        create_dev_server_project(&server, client1.app_state.clone(), cx1, cx2).await;
-    let cx = VisualTestContext::from_window(remote_workspace.into(), cx1).as_mut();
-
-    server.reset().await;
-    cx.run_until_parked();
-
-    cx.simulate_keystrokes("cmd-p 1 enter");
-    remote_workspace
-        .update(cx, |ws, cx| {
-            ws.active_item_as::<Editor>(cx)
-                .unwrap()
-                .update(cx, |ed, cx| {
-                    assert_eq!(ed.text(cx).to_string(), "remote\nremote\nremote");
-                })
-        })
-        .unwrap();
-}
-
 #[gpui::test]
 async fn test_create_dev_server_project_path_validation(
    cx1: &mut gpui::TestAppContext,
--- a/crates/collab_ui/Cargo.toml
+++ b/crates/collab_ui/Cargo.toml
@@ -30,13 +30,17 @@ test-support = [

 [dependencies]
 anyhow.workspace = true
+auto_update.workspace = true
 call.workspace = true
 channel.workspace = true
 client.workspace = true
 collections.workspace = true
+command_palette.workspace = true
 db.workspace = true
 editor.workspace = true
 emojis.workspace = true
+extensions_ui.workspace = true
+feedback.workspace = true
 futures.workspace = true
 fuzzy.workspace = true
 gpui.workspace = true
@@ -47,6 +51,8 @@ notifications.workspace = true
 parking_lot.workspace = true
 picker.workspace = true
 project.workspace = true
+recent_projects.workspace = true
+dev_server_projects.workspace = true
 release_channel.workspace = true
 rich_text.workspace = true
 rpc.workspace = true
@@ -58,13 +64,14 @@ settings.workspace = true
 smallvec.workspace = true
 story = { workspace = true, optional = true }
 theme.workspace = true
+theme_selector.workspace = true
 time_format.workspace = true
 time.workspace = true
-title_bar.workspace = true
 ui.workspace = true
 util.workspace = true
 vcs_menu.workspace = true
 workspace.workspace = true
+zed_actions.workspace = true

 [dev-dependencies]
 call = { workspace = true, features = ["test-support"] }
--- a/crates/collab_ui/src/collab_panel.rs
+++ b/crates/collab_ui/src/collab_panel.rs
@@ -2,7 +2,10 @@ mod channel_modal;
 mod contact_finder;

 use self::channel_modal::ChannelModal;
-use crate::{channel_view::ChannelView, chat_panel::ChatPanel, CollaborationPanelSettings};
+use crate::{
+    channel_view::ChannelView, chat_panel::ChatPanel, face_pile::FacePile,
+    CollaborationPanelSettings,
+};
 use call::ActiveCall;
 use channel::{Channel, ChannelEvent, ChannelStore};
 use client::{ChannelId, Client, Contact, ProjectId, User, UserStore};
@@ -31,8 +34,7 @@ use std::{mem, sync::Arc};
 use theme::{ActiveTheme, ThemeSettings};
 use ui::{
    prelude::*, tooltip_container, Avatar, AvatarAvailabilityIndicator, Button, Color, ContextMenu,
-    Facepile, Icon, IconButton, IconName, IconSize, Indicator, Label, ListHeader, ListItem,
-    Tooltip,
+    Icon, IconButton, IconName, IconSize, Indicator, Label, ListHeader, ListItem, Tooltip,
 };
 use util::{maybe, ResultExt, TryFutureExt};
 use workspace::{
@@ -2540,7 +2542,7 @@ impl CollabPanel {
            None
        } else {
            let extra_count = participants.len().saturating_sub(FACEPILE_LIMIT);
-            let result = Facepile::new(
+            let result = FacePile::new(
                participants
                    .iter()
                    .map(|user| Avatar::new(user.avatar_uri.clone()).into_any_element())
--- a/crates/collab_ui/src/collab_titlebar_item.rs
+++ b/crates/collab_ui/src/collab_titlebar_item.rs
@@ -1,28 +1,21 @@
-mod call_controls;
-mod collab;
-mod platforms;
-mod window_controls;
-
-use crate::platforms::{platform_linux, platform_mac, platform_windows};
+use crate::face_pile::FacePile;
 use auto_update::AutoUpdateStatus;
-use call::{ActiveCall, ParticipantLocation};
-use client::{Client, UserStore};
-use collab::render_color_ribbon;
+use call::{ActiveCall, ParticipantLocation, Room};
+use client::{proto::PeerId, Client, User, UserStore};
 use gpui::{
-    actions, div, px, Action, AnyElement, AppContext, Decorations, Element, InteractiveElement,
-    Interactivity, IntoElement, Model, MouseButton, ParentElement, Render, Stateful,
+    actions, canvas, div, point, px, Action, AnyElement, AppContext, Element, Hsla,
+    InteractiveElement, IntoElement, Model, ParentElement, Path, Render,
    StatefulInteractiveElement, Styled, Subscription, ViewContext, VisualContext, WeakView,
 };
 use project::{Project, RepositoryEntry};
 use recent_projects::RecentProjects;
-use rpc::proto::DevServerStatus;
+use rpc::proto::{self, DevServerStatus};
 use settings::Settings;
-use smallvec::SmallVec;
 use std::sync::Arc;
 use theme::{ActiveTheme, ThemeSettings};
 use ui::{
-    h_flex, prelude::*, Avatar, Button, ButtonLike, ButtonStyle, ContextMenu, Icon, IconButton,
-    IconName, Indicator, PopoverMenu, TintColor, Tooltip,
+    h_flex, prelude::*, Avatar, AvatarAudioStatusIndicator, Button, ButtonLike, ButtonStyle,
+    ContextMenu, Icon, IconButton, IconName, Indicator, PopoverMenu, TintColor, TitleBar, Tooltip,
 };
 use util::ResultExt;
 use vcs_menu::{BranchList, OpenRecent as ToggleVcsMenu};
@@ -44,389 +37,333 @@ actions!(

 pub fn init(cx: &mut AppContext) {
    cx.observe_new_views(|workspace: &mut Workspace, cx| {
-        let item = cx.new_view(|cx| TitleBar::new("title-bar", workspace, cx));
-        workspace.set_titlebar_item(item.into(), cx)
+        let titlebar_item = cx.new_view(|cx| CollabTitlebarItem::new(workspace, cx));
+        workspace.set_titlebar_item(titlebar_item.into(), cx)
    })
    .detach();
 }

-pub struct TitleBar {
-    platform_style: PlatformStyle,
-    content: Stateful<Div>,
-    children: SmallVec<[AnyElement; 2]>,
+pub struct CollabTitlebarItem {
    project: Model<Project>,
    user_store: Model<UserStore>,
    client: Arc<Client>,
    workspace: WeakView<Workspace>,
-    should_move: bool,
    _subscriptions: Vec<Subscription>,
 }

-impl Render for TitleBar {
+impl Render for CollabTitlebarItem {
    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
        let room = ActiveCall::global(cx).read(cx).room().cloned();
        let current_user = self.user_store.read(cx).current_user();
        let client = self.client.clone();
        let project_id = self.project.read(cx).remote_id();
        let workspace = self.workspace.upgrade();
-        let close_action = Box::new(workspace::CloseWindow);

        let platform_supported = cfg!(target_os = "macos");

-        let height = Self::height(cx);
-        let supported_controls = cx.window_controls();
-        let decorations = cx.window_decorations();
-
-        h_flex()
-            .id("titlebar")
-            .w_full()
-            .pt(Self::top_padding(cx))
-            .h(height + Self::top_padding(cx))
-            .map(|this| {
-                if cx.is_fullscreen() {
-                    this.pl_2()
-                } else if self.platform_style == PlatformStyle::Mac {
-                    this.pl(px(platform_mac::TRAFFIC_LIGHT_PADDING))
-                } else {
-                    this.pl_2()
-                }
+        TitleBar::new("collab-titlebar", Box::new(workspace::CloseWindow))
+            // note: on windows titlebar behaviour is handled by the platform implementation
+            .when(cfg!(not(windows)), |this| {
+                this.on_click(|event, cx| {
+                    if event.up.click_count == 2 {
+                        cx.zoom_window();
+                    }
+                })
            })
-            .map(|el| {
-                match decorations {
-                    Decorations::Server => el,
-                    Decorations::Client { tiling, .. } => el
-                        .when(!(tiling.top || tiling.right), |el| {
-                            el.rounded_tr(theme::CLIENT_SIDE_DECORATION_ROUNDING)
-                        })
-                        .when(!(tiling.top || tiling.left), |el| el.rounded_tl(theme::CLIENT_SIDE_DECORATION_ROUNDING))
-                }
-            })
-            .bg(cx.theme().colors().title_bar_background)
-            .content_stretch()
+            // left side
            .child(
-                div()
-                    .id("titlebar-content")
-                    .flex()
-                    .flex_row()
-                    .justify_between()
+                h_flex()
+                    .gap_1()
+                    .children(self.render_application_menu(cx))
+                    .children(self.render_project_host(cx))
+                    .child(self.render_project_name(cx))
+                    .children(self.render_project_branch(cx))
+                    .on_mouse_move(|_, cx| cx.stop_propagation()),
+            )
+            .child(
+                h_flex()
+                    .id("collaborator-list")
                    .w_full()
-                    // note: on windows titlebar behaviour is handled by the platform implementation
-                    .when(cfg!(not(windows)), |this| {
-                        this.on_click(|event, cx| {
-                            if event.up.click_count == 2 {
-                                cx.zoom_window();
-                            }
-                        })
-                    })
-                        // left side
-                        .child(
-                            h_flex()
-                                .gap_1()
-                                .children(self.render_application_menu(cx))
-                                .children(self.render_project_host(cx))
-                                .child(self.render_project_name(cx))
-                                .children(self.render_project_branch(cx))
-                                .on_mouse_down(MouseButton::Left, |_, cx| cx.stop_propagation())
-                        )
-                        .child(
-                            h_flex()
-                                .id("collaborator-list")
-                                .w_full()
-                                .gap_1()
-                                .overflow_x_scroll()
-                                .when_some(
-                                    current_user.clone().zip(client.peer_id()).zip(room.clone()),
-                                    |this, ((current_user, peer_id), room)| {
-                                        let player_colors = cx.theme().players();
-                                        let room = room.read(cx);
-                                        let mut remote_participants =
-                                            room.remote_participants().values().collect::<Vec<_>>();
-                                        remote_participants.sort_by_key(|p| p.participant_index.0);
+                    .gap_1()
+                    .overflow_x_scroll()
+                    .when_some(
+                        current_user.clone().zip(client.peer_id()).zip(room.clone()),
+                        |this, ((current_user, peer_id), room)| {
+                            let player_colors = cx.theme().players();
+                            let room = room.read(cx);
+                            let mut remote_participants =
+                                room.remote_participants().values().collect::<Vec<_>>();
+                            remote_participants.sort_by_key(|p| p.participant_index.0);

-                                        let current_user_face_pile = self.render_collaborator(
-                                            &current_user,
-                                            peer_id,
-                                            true,
-                                            room.is_speaking(),
-                                            room.is_muted(),
-                                            None,
-                                            &room,
-                                            project_id,
-                                            &current_user,
-                                            cx,
-                                        );
+                            let current_user_face_pile = self.render_collaborator(
+                                &current_user,
+                                peer_id,
+                                true,
+                                room.is_speaking(),
+                                room.is_muted(),
+                                None,
+                                &room,
+                                project_id,
+                                &current_user,
+                                cx,
+                            );

-                                        this.children(current_user_face_pile.map(|face_pile| {
-                                            v_flex()
-                                                .on_mouse_down(MouseButton::Left, |_, cx| cx.stop_propagation())
-                                                .child(face_pile)
-                                                .child(render_color_ribbon(player_colors.local().cursor))
-                                        }))
-                                        .children(
-                                            remote_participants.iter().filter_map(|collaborator| {
-                                                let player_color = player_colors
-                                                    .color_for_participant(collaborator.participant_index.0);
-                                                let is_following = workspace
-                                                    .as_ref()?
-                                                    .read(cx)
-                                                    .is_being_followed(collaborator.peer_id);
-                                                let is_present = project_id.map_or(false, |project_id| {
-                                                    collaborator.location
-                                                        == ParticipantLocation::SharedProject { project_id }
-                                                });
+                            this.children(current_user_face_pile.map(|face_pile| {
+                                v_flex()
+                                    .on_mouse_move(|_, cx| cx.stop_propagation())
+                                    .child(face_pile)
+                                    .child(render_color_ribbon(player_colors.local().cursor))
+                            }))
+                            .children(
+                                remote_participants.iter().filter_map(|collaborator| {
+                                    let player_color = player_colors
+                                        .color_for_participant(collaborator.participant_index.0);
+                                    let is_following = workspace
+                                        .as_ref()?
+                                        .read(cx)
+                                        .is_being_followed(collaborator.peer_id);
+                                    let is_present = project_id.map_or(false, |project_id| {
+                                        collaborator.location
+                                            == ParticipantLocation::SharedProject { project_id }
+                                    });

-                                                let facepile = self.render_collaborator(
-                                                    &collaborator.user,
-                                                    collaborator.peer_id,
-                                                    is_present,
-                                                    collaborator.speaking,
-                                                    collaborator.muted,
-                                                    is_following.then_some(player_color.selection),
-                                                    &room,
-                                                    project_id,
-                                                    &current_user,
-                                                    cx,
-                                                )?;
+                                    let face_pile = self.render_collaborator(
+                                        &collaborator.user,
+                                        collaborator.peer_id,
+                                        is_present,
+                                        collaborator.speaking,
+                                        collaborator.muted,
+                                        is_following.then_some(player_color.selection),
+                                        &room,
+                                        project_id,
+                                        &current_user,
+                                        cx,
+                                    )?;

-                                                Some(
-                                                    v_flex()
-                                                        .id(("collaborator", collaborator.user.id))
-                                                        .child(facepile)
-                                                        .child(render_color_ribbon(player_color.cursor))
-                                                        .cursor_pointer()
-                                                        .on_click({
-                                                            let peer_id = collaborator.peer_id;
-                                                            cx.listener(move |this, _, cx| {
-                                                                this.workspace
-                                                                    .update(cx, |workspace, cx| {
-                                                                        workspace.follow(peer_id, cx);
-                                                                    })
-                                                                    .ok();
-                                                            })
+                                    Some(
+                                        v_flex()
+                                            .id(("collaborator", collaborator.user.id))
+                                            .child(face_pile)
+                                            .child(render_color_ribbon(player_color.cursor))
+                                            .cursor_pointer()
+                                            .on_click({
+                                                let peer_id = collaborator.peer_id;
+                                                cx.listener(move |this, _, cx| {
+                                                    this.workspace
+                                                        .update(cx, |workspace, cx| {
+                                                            workspace.follow(peer_id, cx);
                                                        })
-                                                        .tooltip({
-                                                            let login = collaborator.user.github_login.clone();
-                                                            move |cx| {
-                                                                Tooltip::text(format!("Follow {login}"), cx)
-                                                            }
-                                                        }),
-                                                )
-                                            }),
-                                        )
-                                    },
-                                ),
-                        )
-                        // right side
-                        .child(
-                            h_flex()
-                                .gap_1()
-                                .pr_1()
-                                .on_mouse_down(MouseButton::Left, |_, cx| cx.stop_propagation())
-                                .when_some(room, |this, room| {
-                                    let room = room.read(cx);
-                                    let project = self.project.read(cx);
-                                    let is_local = project.is_local();
-                                    let is_dev_server_project = project.dev_server_project_id().is_some();
-                                    let is_shared = (is_local || is_dev_server_project) && project.is_shared();
-                                    let is_muted = room.is_muted();
-                                    let is_deafened = room.is_deafened().unwrap_or(false);
-                                    let is_screen_sharing = room.is_screen_sharing();
-                                    let can_use_microphone = room.can_use_microphone();
-                                    let can_share_projects = room.can_share_projects();
-
-                                    this.when(
-                                        (is_local || is_dev_server_project) && can_share_projects,
-                                        |this| {
-                                            this.child(
-                                                Button::new(
-                                                    "toggle_sharing",
-                                                    if is_shared { "Unshare" } else { "Share" },
-                                                )
-                                                .tooltip(move |cx| {
-                                                    Tooltip::text(
-                                                        if is_shared {
-                                                            "Stop sharing project with call participants"
-                                                        } else {
-                                                            "Share project with call participants"
-                                                        },
-                                                        cx,
-                                                    )
+                                                        .ok();
                                                })
-                                                .style(ButtonStyle::Subtle)
-                                                .selected_style(ButtonStyle::Tinted(TintColor::Accent))
-                                                .selected(is_shared)
-                                                .label_size(LabelSize::Small)
-                                                .on_click(cx.listener(
-                                                    move |this, _, cx| {
-                                                        if is_shared {
-                                                            this.unshare_project(&Default::default(), cx);
-                                                        } else {
-                                                            this.share_project(&Default::default(), cx);
-                                                        }
-                                                    },
-                                                )),
-                                            )
-                                        },
-                                    )
-                                    .child(
-                                        div()
-                                            .child(
-                                                IconButton::new("leave-call", ui::IconName::Exit)
-                                                    .style(ButtonStyle::Subtle)
-                                                    .tooltip(|cx| Tooltip::text("Leave call", cx))
-                                                    .icon_size(IconSize::Small)
-                                                    .on_click(move |_, cx| {
-                                                        ActiveCall::global(cx)
-                                                            .update(cx, |call, cx| call.hang_up(cx))
-                                                            .detach_and_log_err(cx);
-                                                    }),
-                                            )
-                                            .pr_2(),
-                                    )
-                                    .when(can_use_microphone, |this| {
-                                        this.child(
-                                            IconButton::new(
-                                                "mute-microphone",
-                                                if is_muted {
-                                                    ui::IconName::MicMute
-                                                } else {
-                                                    ui::IconName::Mic
-                                                },
-                                            )
-                                            .tooltip(move |cx| {
-                                                Tooltip::text(
-                                                    if !platform_supported {
-                                                        "Cannot share microphone"
-                                                    } else if is_muted {
-                                                        "Unmute microphone"
-                                                    } else {
-                                                        "Mute microphone"
-                                                    },
-                                                    cx,
-                                                )
                                            })
-                                            .style(ButtonStyle::Subtle)
-                                            .icon_size(IconSize::Small)
-                                            .selected(platform_supported && is_muted)
-                                            .disabled(!platform_supported)
-                                            .selected_style(ButtonStyle::Tinted(TintColor::Negative))
-                                            .on_click(move |_, cx| {
-                                                call_controls::toggle_mute(&Default::default(), cx);
+                                            .tooltip({
+                                                let login = collaborator.user.github_login.clone();
+                                                move |cx| {
+                                                    Tooltip::text(format!("Follow {login}"), cx)
+                                                }
                                            }),
-                                        )
-                                    })
-                                    .child(
-                                        IconButton::new(
-                                            "mute-sound",
-                                            if is_deafened {
-                                                ui::IconName::AudioOff
-                                            } else {
-                                                ui::IconName::AudioOn
-                                            },
-                                        )
-                                        .style(ButtonStyle::Subtle)
-                                        .selected_style(ButtonStyle::Tinted(TintColor::Negative))
-                                        .icon_size(IconSize::Small)
-                                        .selected(is_deafened)
-                                        .disabled(!platform_supported)
-                                        .tooltip(move |cx| {
-                                            if !platform_supported {
-                                                Tooltip::text("Cannot share microphone", cx)
-                                            } else if can_use_microphone {
-                                                Tooltip::with_meta(
-                                                    "Deafen Audio",
-                                                    None,
-                                                    "Mic will be muted",
-                                                    cx,
-                                                )
-                                            } else {
-                                                Tooltip::text("Deafen Audio", cx)
-                                            }
-                                        })
-                                        .on_click(move |_, cx| {
-                                            call_controls::toggle_deafen(&Default::default(), cx)
-                                        }),
                                    )
-                                    .when(can_share_projects, |this| {
-                                        this.child(
-                                            IconButton::new("screen-share", ui::IconName::Screen)
-                                                .style(ButtonStyle::Subtle)
-                                                .icon_size(IconSize::Small)
-                                                .selected(is_screen_sharing)
-                                                .disabled(!platform_supported)
-                                                .selected_style(ButtonStyle::Tinted(TintColor::Accent))
-                                                .tooltip(move |cx| {
-                                                    Tooltip::text(
-                                                        if !platform_supported {
-                                                            "Cannot share screen"
-                                                        } else if is_screen_sharing {
-                                                            "Stop Sharing Screen"
-                                                        } else {
-                                                            "Share Screen"
-                                                        },
-                                                        cx,
-                                                    )
-                                                })
-                                                .on_click(move |_, cx| {
-                                                    call_controls::toggle_screen_sharing(&Default::default(), cx)
-                                                }),
+                                }),
+                            )
+                        },
+                    ),
+            )
+            // right side
+            .child(
+                h_flex()
+                    .gap_1()
+                    .pr_1()
+                    .on_mouse_move(|_, cx| cx.stop_propagation())
+                    .when_some(room, |this, room| {
+                        let room = room.read(cx);
+                        let project = self.project.read(cx);
+                        let is_local = project.is_local();
+                        let is_dev_server_project = project.dev_server_project_id().is_some();
+                        let is_shared = (is_local || is_dev_server_project) && project.is_shared();
+                        let is_muted = room.is_muted();
+                        let is_deafened = room.is_deafened().unwrap_or(false);
+                        let is_screen_sharing = room.is_screen_sharing();
+                        let can_use_microphone = room.can_use_microphone();
+                        let can_share_projects = room.can_share_projects();
+
+                        this.when(
+                            (is_local || is_dev_server_project) && can_share_projects,
+                            |this| {
+                                this.child(
+                                    Button::new(
+                                        "toggle_sharing",
+                                        if is_shared { "Unshare" } else { "Share" },
+                                    )
+                                    .tooltip(move |cx| {
+                                        Tooltip::text(
+                                            if is_shared {
+                                                "Stop sharing project with call participants"
+                                            } else {
+                                                "Share project with call participants"
+                                            },
+                                            cx,
                                        )
                                    })
-                                    .child(div().pr_2())
-                                })
-                                .map(|el| {
-                                    let status = self.client.status();
-                                    let status = &*status.borrow();
-                                    if matches!(status, client::Status::Connected { .. }) {
-                                        el.child(self.render_user_menu_button(cx))
-                                    } else {
-                                        el.children(self.render_connection_status(status, cx))
-                                            .child(self.render_sign_in_button(cx))
-                                            .child(self.render_user_menu_button(cx))
-                                    }
-                                }),
-                        )
-
-            ).when(
-            self.platform_style == PlatformStyle::Windows && !cx.is_fullscreen(),
-            |title_bar| title_bar.child(platform_windows::WindowsWindowControls::new(height)),
-        ).when(
-            self.platform_style == PlatformStyle::Linux
-                && !cx.is_fullscreen()
-                && matches!(decorations, Decorations::Client { .. }),
-            |title_bar| {
-                title_bar
-                    .child(platform_linux::LinuxWindowControls::new(close_action))
-                    .when(supported_controls.window_menu, |titlebar| {
-                        titlebar.on_mouse_down(gpui::MouseButton::Right, move |ev, cx| {
-                            cx.show_window_menu(ev.position)
-                        })
-                    })
-
-                                        .on_mouse_move(cx.listener(move |this, _ev, cx| {
-                                            if this.should_move {
-                                                this.should_move = false;
-                                                cx.start_window_move();
+                                    .style(ButtonStyle::Subtle)
+                                    .selected_style(ButtonStyle::Tinted(TintColor::Accent))
+                                    .selected(is_shared)
+                                    .label_size(LabelSize::Small)
+                                    .on_click(cx.listener(
+                                        move |this, _, cx| {
+                                            if is_shared {
+                                                this.unshare_project(&Default::default(), cx);
+                                            } else {
+                                                this.share_project(&Default::default(), cx);
                                            }
-                                        }))
-                                        .on_mouse_down_out(cx.listener(move |this, _ev, _cx| {
-                                            this.should_move = false;
-                                        }))
-                                        .on_mouse_down(gpui::MouseButton::Left, cx.listener(move |this, _ev, _cx| {
-                                            this.should_move = true;
-                                    }))
-
-            },
-        )
+                                        },
+                                    )),
+                                )
+                            },
+                        )
+                        .child(
+                            div()
+                                .child(
+                                    IconButton::new("leave-call", ui::IconName::Exit)
+                                        .style(ButtonStyle::Subtle)
+                                        .tooltip(|cx| Tooltip::text("Leave call", cx))
+                                        .icon_size(IconSize::Small)
+                                        .on_click(move |_, cx| {
+                                            ActiveCall::global(cx)
+                                                .update(cx, |call, cx| call.hang_up(cx))
+                                                .detach_and_log_err(cx);
+                                        }),
+                                )
+                                .pr_2(),
+                        )
+                        .when(can_use_microphone, |this| {
+                            this.child(
+                                IconButton::new(
+                                    "mute-microphone",
+                                    if is_muted {
+                                        ui::IconName::MicMute
+                                    } else {
+                                        ui::IconName::Mic
+                                    },
+                                )
+                                .tooltip(move |cx| {
+                                    Tooltip::text(
+                                        if !platform_supported {
+                                            "Cannot share microphone"
+                                        } else if is_muted {
+                                            "Unmute microphone"
+                                        } else {
+                                            "Mute microphone"
+                                        },
+                                        cx,
+                                    )
+                                })
+                                .style(ButtonStyle::Subtle)
+                                .icon_size(IconSize::Small)
+                                .selected(platform_supported && is_muted)
+                                .disabled(!platform_supported)
+                                .selected_style(ButtonStyle::Tinted(TintColor::Negative))
+                                .on_click(move |_, cx| crate::toggle_mute(&Default::default(), cx)),
+                            )
+                        })
+                        .child(
+                            IconButton::new(
+                                "mute-sound",
+                                if is_deafened {
+                                    ui::IconName::AudioOff
+                                } else {
+                                    ui::IconName::AudioOn
+                                },
+                            )
+                            .style(ButtonStyle::Subtle)
+                            .selected_style(ButtonStyle::Tinted(TintColor::Negative))
+                            .icon_size(IconSize::Small)
+                            .selected(is_deafened)
+                            .disabled(!platform_supported)
+                            .tooltip(move |cx| {
+                                if !platform_supported {
+                                    Tooltip::text("Cannot share microphone", cx)
+                                } else if can_use_microphone {
+                                    Tooltip::with_meta(
+                                        "Deafen Audio",
+                                        None,
+                                        "Mic will be muted",
+                                        cx,
+                                    )
+                                } else {
+                                    Tooltip::text("Deafen Audio", cx)
+                                }
+                            })
+                            .on_click(move |_, cx| crate::toggle_deafen(&Default::default(), cx)),
+                        )
+                        .when(can_share_projects, |this| {
+                            this.child(
+                                IconButton::new("screen-share", ui::IconName::Screen)
+                                    .style(ButtonStyle::Subtle)
+                                    .icon_size(IconSize::Small)
+                                    .selected(is_screen_sharing)
+                                    .disabled(!platform_supported)
+                                    .selected_style(ButtonStyle::Tinted(TintColor::Accent))
+                                    .tooltip(move |cx| {
+                                        Tooltip::text(
+                                            if !platform_supported {
+                                                "Cannot share screen"
+                                            } else if is_screen_sharing {
+                                                "Stop Sharing Screen"
+                                            } else {
+                                                "Share Screen"
+                                            },
+                                            cx,
+                                        )
+                                    })
+                                    .on_click(move |_, cx| {
+                                        crate::toggle_screen_sharing(&Default::default(), cx)
+                                    }),
+                            )
+                        })
+                        .child(div().pr_2())
+                    })
+                    .map(|el| {
+                        let status = self.client.status();
+                        let status = &*status.borrow();
+                        if matches!(status, client::Status::Connected { .. }) {
+                            el.child(self.render_user_menu_button(cx))
+                        } else {
+                            el.children(self.render_connection_status(status, cx))
+                                .child(self.render_sign_in_button(cx))
+                                .child(self.render_user_menu_button(cx))
+                        }
+                    }),
+            )
    }
 }

-impl TitleBar {
-    pub fn new(
-        id: impl Into<ElementId>,
-        workspace: &Workspace,
-        cx: &mut ViewContext<Self>,
-    ) -> Self {
+fn render_color_ribbon(color: Hsla) -> impl Element {
+    canvas(
+        move |_, _| {},
+        move |bounds, _, cx| {
+            let height = bounds.size.height;
+            let horizontal_offset = height;
+            let vertical_offset = px(height.0 / 2.0);
+            let mut path = Path::new(bounds.lower_left());
+            path.curve_to(
+                bounds.origin + point(horizontal_offset, vertical_offset),
+                bounds.origin + point(px(0.0), vertical_offset),
+            );
+            path.line_to(bounds.upper_right() + point(-horizontal_offset, vertical_offset));
+            path.curve_to(
+                bounds.lower_right(),
+                bounds.upper_right() + point(px(0.0), vertical_offset),
+            );
+            path.line_to(bounds.lower_left());
+            cx.paint_path(path, color);
+        },
+    )
+    .h_1()
+    .w_full()
+}
+
+impl CollabTitlebarItem {
+    pub fn new(workspace: &Workspace, cx: &mut ViewContext<Self>) -> Self {
        let project = workspace.project().clone();
        let user_store = workspace.app_state().user_store.clone();
        let client = workspace.app_state().client.clone();
@@ -443,11 +380,7 @@ impl TitleBar {
        subscriptions.push(cx.observe(&user_store, |_, _, cx| cx.notify()));

        Self {
-            platform_style: PlatformStyle::platform(),
-            content: div().id(id.into()),
-            children: SmallVec::new(),
            workspace: workspace.weak_handle(),
-            should_move: false,
            project,
            user_store,
            client,
@@ -455,45 +388,6 @@ impl TitleBar {
        }
    }

-    #[cfg(not(target_os = "windows"))]
-    pub fn height(cx: &mut WindowContext) -> Pixels {
-        (1.75 * cx.rem_size()).max(px(34.))
-    }
-
-    #[cfg(target_os = "windows")]
-    pub fn height(_cx: &mut WindowContext) -> Pixels {
-        // todo(windows) instead of hard coded size report the actual size to the Windows platform API
-        px(32.)
-    }
-
-    #[cfg(not(target_os = "windows"))]
-    fn top_padding(_cx: &WindowContext) -> Pixels {
-        px(0.)
-    }
-
-    #[cfg(target_os = "windows")]
-    fn top_padding(cx: &WindowContext) -> Pixels {
-        use windows::Win32::UI::{
-            HiDpi::GetSystemMetricsForDpi,
-            WindowsAndMessaging::{SM_CXPADDEDBORDER, USER_DEFAULT_SCREEN_DPI},
-        };
-
-        // This top padding is not dependent on the title bar style and is instead a quirk of maximized windows on Windows:
-        // https://devblogs.microsoft.com/oldnewthing/20150304-00/?p=44543
-        let padding = unsafe { GetSystemMetricsForDpi(SM_CXPADDEDBORDER, USER_DEFAULT_SCREEN_DPI) };
-        if cx.is_maximized() {
-            px((padding * 2) as f32)
-        } else {
-            px(0.)
-        }
-    }
-
-    /// Sets the platform style.
-    pub fn platform_style(mut self, style: PlatformStyle) -> Self {
-        self.platform_style = style;
-        self
-    }
-
    pub fn render_application_menu(&self, cx: &mut ViewContext<Self>) -> Option<AnyElement> {
        cfg!(not(target_os = "macos")).then(|| {
            let ui_font_size = ThemeSettings::get_global(cx).ui_font_size;
@@ -818,6 +712,97 @@ impl TitleBar {
        )
    }

+    #[allow(clippy::too_many_arguments)]
+    fn render_collaborator(
+        &self,
+        user: &Arc<User>,
+        peer_id: PeerId,
+        is_present: bool,
+        is_speaking: bool,
+        is_muted: bool,
+        leader_selection_color: Option<Hsla>,
+        room: &Room,
+        project_id: Option<u64>,
+        current_user: &Arc<User>,
+        cx: &ViewContext<Self>,
+    ) -> Option<Div> {
+        if room.role_for_user(user.id) == Some(proto::ChannelRole::Guest) {
+            return None;
+        }
+
+        const FACEPILE_LIMIT: usize = 3;
+        let followers = project_id.map_or(&[] as &[_], |id| room.followers_for(peer_id, id));
+        let extra_count = followers.len().saturating_sub(FACEPILE_LIMIT);
+
+        Some(
+            div()
+                .m_0p5()
+                .p_0p5()
+                // When the collaborator is not followed, still draw this wrapper div, but leave
+                // it transparent, so that it does not shift the layout when following.
+                .when_some(leader_selection_color, |div, color| {
+                    div.rounded_md().bg(color)
+                })
+                .child(
+                    FacePile::empty()
+                        .child(
+                            Avatar::new(user.avatar_uri.clone())
+                                .grayscale(!is_present)
+                                .border_color(if is_speaking {
+                                    cx.theme().status().info
+                                } else {
+                                    // We draw the border in a transparent color rather to avoid
+                                    // the layout shift that would come with adding/removing the border.
+                                    gpui::transparent_black()
+                                })
+                                .when(is_muted, |avatar| {
+                                    avatar.indicator(
+                                        AvatarAudioStatusIndicator::new(ui::AudioStatus::Muted)
+                                            .tooltip({
+                                                let github_login = user.github_login.clone();
+                                                move |cx| {
+                                                    Tooltip::text(
+                                                        format!("{} is muted", github_login),
+                                                        cx,
+                                                    )
+                                                }
+                                            }),
+                                    )
+                                }),
+                        )
+                        .children(followers.iter().take(FACEPILE_LIMIT).filter_map(
+                            |follower_peer_id| {
+                                let follower = room
+                                    .remote_participants()
+                                    .values()
+                                    .find_map(|p| {
+                                        (p.peer_id == *follower_peer_id).then_some(&p.user)
+                                    })
+                                    .or_else(|| {
+                                        (self.client.peer_id() == Some(*follower_peer_id))
+                                            .then_some(current_user)
+                                    })?
+                                    .clone();
+
+                                Some(div().mt(-px(4.)).child(
+                                    Avatar::new(follower.avatar_uri.clone()).size(rems(0.75)),
+                                ))
+                            },
+                        ))
+                        .children(if extra_count > 0 {
+                            Some(
+                                div()
+                                    .ml_1()
+                                    .child(Label::new(format!("+{extra_count}")))
+                                    .into_any_element(),
+                            )
+                        } else {
+                            None
+                        }),
+                ),
+        )
+    }
+
    fn window_activation_changed(&mut self, cx: &mut ViewContext<Self>) {
        if cx.is_window_active() {
            ActiveCall::global(cx)
@@ -975,17 +960,3 @@ impl TitleBar {
        }
    }
 }
-
-impl InteractiveElement for TitleBar {
-    fn interactivity(&mut self) -> &mut Interactivity {
-        self.content.interactivity()
-    }
-}
-
-impl StatefulInteractiveElement for TitleBar {}
-
-impl ParentElement for TitleBar {
-    fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>) {
-        self.children.extend(elements)
-    }
-}
--- a/crates/collab_ui/src/collab_ui.rs
+++ b/crates/collab_ui/src/collab_ui.rs
@@ -1,16 +1,20 @@
 pub mod channel_view;
 pub mod chat_panel;
 pub mod collab_panel;
+mod collab_titlebar_item;
+mod face_pile;
 pub mod notification_panel;
 pub mod notifications;
 mod panel_settings;

 use std::{rc::Rc, sync::Arc};

+use call::{report_call_event_for_room, ActiveCall};
 pub use collab_panel::CollabPanel;
+pub use collab_titlebar_item::CollabTitlebarItem;
 use gpui::{
-    point, AppContext, Pixels, PlatformDisplay, Size, WindowBackgroundAppearance, WindowBounds,
-    WindowDecorations, WindowKind, WindowOptions,
+    actions, point, AppContext, Pixels, PlatformDisplay, Size, Task, WindowBackgroundAppearance,
+    WindowBounds, WindowContext, WindowKind, WindowOptions,
 };
 use panel_settings::MessageEditorSettings;
 pub use panel_settings::{
@@ -19,7 +23,12 @@ pub use panel_settings::{
 use release_channel::ReleaseChannel;
 use settings::Settings;
 use ui::px;
-use workspace::AppState;
+use workspace::{notifications::DetachAndPromptErr, AppState};
+
+actions!(
+    collab,
+    [ToggleScreenSharing, ToggleMute, ToggleDeafen, LeaveCall]
+);

 pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
    CollaborationPanelSettings::register(cx);
@@ -27,13 +36,63 @@ pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
    NotificationPanelSettings::register(cx);
    MessageEditorSettings::register(cx);

+    vcs_menu::init(cx);
+    collab_titlebar_item::init(cx);
+    collab_panel::init(cx);
    channel_view::init(cx);
    chat_panel::init(cx);
-    collab_panel::init(cx);
    notification_panel::init(cx);
    notifications::init(&app_state, cx);
-    title_bar::init(cx);
-    vcs_menu::init(cx);
+}
+
+pub fn toggle_screen_sharing(_: &ToggleScreenSharing, cx: &mut WindowContext) {
+    let call = ActiveCall::global(cx).read(cx);
+    if let Some(room) = call.room().cloned() {
+        let client = call.client();
+        let toggle_screen_sharing = room.update(cx, |room, cx| {
+            if room.is_screen_sharing() {
+                report_call_event_for_room(
+                    "disable screen share",
+                    room.id(),
+                    room.channel_id(),
+                    &client,
+                );
+                Task::ready(room.unshare_screen(cx))
+            } else {
+                report_call_event_for_room(
+                    "enable screen share",
+                    room.id(),
+                    room.channel_id(),
+                    &client,
+                );
+                room.share_screen(cx)
+            }
+        });
+        toggle_screen_sharing.detach_and_prompt_err("Sharing Screen Failed", cx, |e, _| Some(format!("{:?}\n\nPlease check that you have given Zed permissions to record your screen in Settings.", e)));
+    }
+}
+
+pub fn toggle_mute(_: &ToggleMute, cx: &mut AppContext) {
+    let call = ActiveCall::global(cx).read(cx);
+    if let Some(room) = call.room().cloned() {
+        let client = call.client();
+        room.update(cx, |room, cx| {
+            let operation = if room.is_muted() {
+                "enable microphone"
+            } else {
+                "disable microphone"
+            };
+            report_call_event_for_room(operation, room.id(), room.channel_id(), &client);
+
+            room.toggle_mute(cx)
+        });
+    }
+}
+
+pub fn toggle_deafen(_: &ToggleDeafen, cx: &mut AppContext) {
+    if let Some(room) = ActiveCall::global(cx).read(cx).room().cloned() {
+        room.update(cx, |room, cx| room.toggle_deafen(cx));
+    }
 }

 fn notification_window_options(
@@ -63,9 +122,7 @@ fn notification_window_options(
        kind: WindowKind::PopUp,
        is_movable: false,
        display_id: Some(screen.id()),
-        window_background: WindowBackgroundAppearance::Transparent,
+        window_background: WindowBackgroundAppearance::default(),
        app_id: Some(app_id.to_owned()),
-        window_min_size: None,
-        window_decorations: Some(WindowDecorations::Client),
    }
 }
--- a/crates/ui/src/components/facepile.rs
+++ b/crates/ui/src/components/facepile.rs
@@ -1,19 +1,14 @@
-use crate::prelude::*;
 use gpui::AnyElement;
 use smallvec::SmallVec;
+use ui::prelude::*;

-/// A facepile is a collection of faces stacked horizontally–
-/// always with the leftmost face on top and descending in z-index
-///
-/// Facepiles are used to display a group of people or things,
-/// such as a list of participants in a collaboration session.
 #[derive(IntoElement)]
-pub struct Facepile {
+pub struct FacePile {
    base: Div,
    faces: SmallVec<[AnyElement; 2]>,
 }

-impl Facepile {
+impl FacePile {
    pub fn empty() -> Self {
        Self::new(SmallVec::new())
    }
@@ -23,7 +18,7 @@ impl Facepile {
    }
 }

-impl RenderOnce for Facepile {
+impl RenderOnce for FacePile {
    fn render(self, _cx: &mut WindowContext) -> impl IntoElement {
        // Lay the faces out in reverse so they overlap in the desired order (left to right, front to back)
        self.base
@@ -41,13 +36,13 @@ impl RenderOnce for Facepile {
    }
 }

-impl ParentElement for Facepile {
+impl ParentElement for FacePile {
    fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>) {
        self.faces.extend(elements);
    }
 }

-impl Styled for Facepile {
+impl Styled for FacePile {
    fn style(&mut self) -> &mut gpui::StyleRefinement {
        self.base.style()
    }
--- a/crates/diagnostics/src/diagnostics.rs
+++ b/crates/diagnostics/src/diagnostics.rs
@@ -102,9 +102,6 @@ impl Render for ProjectDiagnosticsEditor {

        div()
            .track_focus(&self.focus_handle)
-            .when(self.path_states.is_empty(), |el| {
-                el.key_context("EmptyPane")
-            })
            .size_full()
            .on_action(cx.listener(Self::toggle_warnings))
            .child(child)
--- a/crates/editor/src/actions.rs
+++ b/crates/editor/src/actions.rs
@@ -268,7 +268,6 @@ gpui::actions!(
        SelectAllMatches,
        SelectDown,
        SelectLargerSyntaxNode,
-        SelectEnclosingSymbol,
        SelectLeft,
        SelectLine,
        SelectRight,
--- a/crates/editor/src/display_map.rs
+++ b/crates/editor/src/display_map.rs
@@ -720,7 +720,8 @@ impl DisplaySnapshot {
            if let Some(severity) = chunk.diagnostic_severity {
                // Omit underlines for HINT/INFO diagnostics on 'unnecessary' code.
                if severity <= DiagnosticSeverity::WARNING || !chunk.is_unnecessary {
-                    let diagnostic_color = super::diagnostic_style(severity, &editor_style.status);
+                    let diagnostic_color =
+                        super::diagnostic_style(severity, true, &editor_style.status);
                    diagnostic_highlight.underline = Some(UnderlineStyle {
                        color: Some(diagnostic_color),
                        thickness: 1.0.into(),
@@ -956,18 +957,16 @@ impl DisplaySnapshot {
            return false;
        }

-        (buffer_row.0 + 1..=max_row.0)
-            .find_map(|next_row| {
-                let next_line_indent = self.line_indent_for_buffer_row(MultiBufferRow(next_row));
-                if next_line_indent.raw_len() > line_indent.raw_len() {
-                    Some(true)
-                } else if !next_line_indent.is_line_blank() {
-                    Some(false)
-                } else {
-                    None
-                }
-            })
-            .unwrap_or(false)
+        for next_row in (buffer_row.0 + 1)..=max_row.0 {
+            let next_line_indent = self.line_indent_for_buffer_row(MultiBufferRow(next_row));
+            if next_line_indent.raw_len() > line_indent.raw_len() {
+                return true;
+            } else if !next_line_indent.is_line_blank() {
+                break;
+            }
+        }
+
+        false
    }

    pub fn foldable_range(
--- a/crates/editor/src/display_map/block_map.rs
+++ b/crates/editor/src/display_map/block_map.rs
@@ -1221,7 +1221,7 @@ mod tests {
    use super::*;
    use crate::display_map::inlay_map::InlayMap;
    use crate::display_map::{fold_map::FoldMap, tab_map::TabMap, wrap_map::WrapMap};
-    use gpui::{div, font, px, Element};
+    use gpui::{div, font, px, AssetSource, Element};
    use multi_buffer::MultiBuffer;
    use rand::prelude::*;
    use settings::SettingsStore;
@@ -2014,7 +2014,12 @@ mod tests {
        let settings = SettingsStore::test(cx);
        cx.set_global(settings);
        theme::init(theme::LoadThemes::JustBase, cx);
-        assets::Assets.load_test_fonts(cx);
+        cx.text_system()
+            .add_fonts(vec![assets::Assets
+                .load("fonts/zed-mono/zed-mono-extended.ttf")
+                .unwrap()
+                .unwrap()])
+            .unwrap();
    }

    impl TransformBlock {
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -335,7 +335,7 @@ pub enum SelectMode {

 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub enum EditorMode {
-    SingleLine { auto_width: bool },
+    SingleLine,
    AutoHeight { max_lines: usize },
    Full,
 }
@@ -1580,13 +1580,7 @@ impl Editor {
    pub fn single_line(cx: &mut ViewContext<Self>) -> Self {
        let buffer = cx.new_model(|cx| Buffer::local("", cx));
        let buffer = cx.new_model(|cx| MultiBuffer::singleton(buffer, cx));
-        Self::new(
-            EditorMode::SingleLine { auto_width: false },
-            buffer,
-            None,
-            false,
-            cx,
-        )
+        Self::new(EditorMode::SingleLine, buffer, None, false, cx)
    }

    pub fn multi_line(cx: &mut ViewContext<Self>) -> Self {
@@ -1595,18 +1589,6 @@ impl Editor {
        Self::new(EditorMode::Full, buffer, None, false, cx)
    }

-    pub fn auto_width(cx: &mut ViewContext<Self>) -> Self {
-        let buffer = cx.new_model(|cx| Buffer::local("", cx));
-        let buffer = cx.new_model(|cx| MultiBuffer::singleton(buffer, cx));
-        Self::new(
-            EditorMode::SingleLine { auto_width: true },
-            buffer,
-            None,
-            false,
-            cx,
-        )
-    }
-
    pub fn auto_height(max_lines: usize, cx: &mut ViewContext<Self>) -> Self {
        let buffer = cx.new_model(|cx| Buffer::local("", cx));
        let buffer = cx.new_model(|cx| MultiBuffer::singleton(buffer, cx));
@@ -1719,8 +1701,8 @@ impl Editor {

        let blink_manager = cx.new_model(|cx| BlinkManager::new(CURSOR_BLINK_INTERVAL, cx));

-        let soft_wrap_mode_override = matches!(mode, EditorMode::SingleLine { .. })
-            .then(|| language_settings::SoftWrap::PreferLine);
+        let soft_wrap_mode_override =
+            (mode == EditorMode::SingleLine).then(|| language_settings::SoftWrap::PreferLine);

        let mut project_subscriptions = Vec::new();
        if mode == EditorMode::Full {
@@ -1767,7 +1749,7 @@ impl Editor {
            .detach();
        cx.on_blur(&focus_handle, Self::handle_blur).detach();

-        let show_indent_guides = if matches!(mode, EditorMode::SingleLine { .. }) {
+        let show_indent_guides = if mode == EditorMode::SingleLine {
            Some(false)
        } else {
            None
@@ -1923,15 +1905,10 @@ impl Editor {
        let mut key_context = KeyContext::new_with_defaults();
        key_context.add("Editor");
        let mode = match self.mode {
-            EditorMode::SingleLine { .. } => "single_line",
+            EditorMode::SingleLine => "single_line",
            EditorMode::AutoHeight { .. } => "auto_height",
            EditorMode::Full => "full",
        };
-
-        if EditorSettings::get_global(cx).jupyter.enabled {
-            key_context.add("jupyter");
-        }
-
        key_context.set("mode", mode);
        if self.pending_rename.is_some() {
            key_context.add("renaming");
@@ -2136,7 +2113,7 @@ impl Editor {
        self.refresh_inline_completion(false, cx);
    }

-    pub fn placeholder_text(&self, _cx: &WindowContext) -> Option<&str> {
+    pub fn placeholder_text(&self, _cx: &mut WindowContext) -> Option<&str> {
        self.placeholder_text.as_deref()
    }

@@ -2919,9 +2896,6 @@ impl Editor {
            let start_offset = TO::to_offset(&range.start, &buffer_snapshot);
            let end_offset = start_offset + end_difference;
            let start_offset = start_offset + start_difference;
-            if start_offset > buffer_snapshot.len() || end_offset > buffer_snapshot.len() {
-                continue;
-            }
            let start = buffer_snapshot.anchor_after(start_offset);
            let end = buffer_snapshot.anchor_after(end_offset);
            linked_edits
@@ -3128,24 +3102,14 @@ impl Editor {
            let anchor = snapshot.anchor_after(selection.end);
            if !self.linked_edit_ranges.is_empty() {
                let start_anchor = snapshot.anchor_before(selection.start);
-
-                let is_word_char = text.chars().next().map_or(true, |char| {
-                    let scope = snapshot.language_scope_at(start_anchor.to_offset(&snapshot));
-                    let kind = char_kind(&scope, char);
-
-                    kind == CharKind::Word
-                });
-
-                if is_word_char {
-                    if let Some(ranges) = self
-                        .linked_editing_ranges_for(start_anchor.text_anchor..anchor.text_anchor, cx)
-                    {
-                        for (buffer, edits) in ranges {
-                            linked_edits
-                                .entry(buffer.clone())
-                                .or_default()
-                                .extend(edits.into_iter().map(|range| (range, text.clone())));
-                        }
+                if let Some(ranges) =
+                    self.linked_editing_ranges_for(start_anchor.text_anchor..anchor.text_anchor, cx)
+                {
+                    for (buffer, edits) in ranges {
+                        linked_edits
+                            .entry(buffer.clone())
+                            .or_default()
+                            .extend(edits.into_iter().map(|range| (range, text.clone())));
                    }
                }
            }
@@ -6696,7 +6660,7 @@ impl Editor {
            return;
        }

-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
            cx.propagate();
            return;
        }
@@ -6733,7 +6697,7 @@ impl Editor {
            return;
        }

-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
            cx.propagate();
            return;
        }
@@ -6764,7 +6728,7 @@ impl Editor {
            return;
        }

-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
            cx.propagate();
            return;
        }
@@ -6827,17 +6791,7 @@ impl Editor {
            return;
        }

-        if self
-            .context_menu
-            .write()
-            .as_mut()
-            .map(|menu| menu.select_first(self.project.as_ref(), cx))
-            .unwrap_or(false)
-        {
-            return;
-        }
-
-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
            cx.propagate();
            return;
        }
@@ -6885,7 +6839,7 @@ impl Editor {
    pub fn move_down(&mut self, _: &MoveDown, cx: &mut ViewContext<Self>) {
        self.take_rename(true, cx);

-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if self.mode == EditorMode::SingleLine {
            cx.propagate();
            return;
        }
@@ -6946,7 +6900,7 @@ impl Editor {
            return;
        }

-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
            cx.propagate();
            return;
        }
@@ -7294,7 +7248,7 @@ impl Editor {
        _: &MoveToStartOfParagraph,
        cx: &mut ViewContext<Self>,
    ) {
-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
            cx.propagate();
            return;
        }
@@ -7314,7 +7268,7 @@ impl Editor {
        _: &MoveToEndOfParagraph,
        cx: &mut ViewContext<Self>,
    ) {
-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
            cx.propagate();
            return;
        }
@@ -7334,7 +7288,7 @@ impl Editor {
        _: &SelectToStartOfParagraph,
        cx: &mut ViewContext<Self>,
    ) {
-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
            cx.propagate();
            return;
        }
@@ -7354,7 +7308,7 @@ impl Editor {
        _: &SelectToEndOfParagraph,
        cx: &mut ViewContext<Self>,
    ) {
-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
            cx.propagate();
            return;
        }
@@ -7370,7 +7324,7 @@ impl Editor {
    }

    pub fn move_to_beginning(&mut self, _: &MoveToBeginning, cx: &mut ViewContext<Self>) {
-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
            cx.propagate();
            return;
        }
@@ -7390,7 +7344,7 @@ impl Editor {
    }

    pub fn move_to_end(&mut self, _: &MoveToEnd, cx: &mut ViewContext<Self>) {
-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
            cx.propagate();
            return;
        }
@@ -8249,7 +8203,7 @@ impl Editor {
            let advance_downwards = action.advance_downwards
                && selections_on_single_row
                && !selections_selecting
-                && !matches!(this.mode, EditorMode::SingleLine { .. });
+                && this.mode != EditorMode::SingleLine;

            if advance_downwards {
                let snapshot = this.buffer.read(cx).snapshot(cx);
@@ -8272,58 +8226,6 @@ impl Editor {
        });
    }

-    pub fn select_enclosing_symbol(
-        &mut self,
-        _: &SelectEnclosingSymbol,
-        cx: &mut ViewContext<Self>,
-    ) {
-        let buffer = self.buffer.read(cx).snapshot(cx);
-        let old_selections = self.selections.all::<usize>(cx).into_boxed_slice();
-
-        fn update_selection(
-            selection: &Selection<usize>,
-            buffer_snap: &MultiBufferSnapshot,
-        ) -> Option<Selection<usize>> {
-            let cursor = selection.head();
-            let (_buffer_id, symbols) = buffer_snap.symbols_containing(cursor, None)?;
-            for symbol in symbols.iter().rev() {
-                let start = symbol.range.start.to_offset(&buffer_snap);
-                let end = symbol.range.end.to_offset(&buffer_snap);
-                let new_range = start..end;
-                if start < selection.start || end > selection.end {
-                    return Some(Selection {
-                        id: selection.id,
-                        start: new_range.start,
-                        end: new_range.end,
-                        goal: SelectionGoal::None,
-                        reversed: selection.reversed,
-                    });
-                }
-            }
-            None
-        }
-
-        let mut selected_larger_symbol = false;
-        let new_selections = old_selections
-            .iter()
-            .map(|selection| match update_selection(selection, &buffer) {
-                Some(new_selection) => {
-                    if new_selection.range() != selection.range() {
-                        selected_larger_symbol = true;
-                    }
-                    new_selection
-                }
-                None => selection.clone(),
-            })
-            .collect::<Vec<_>>();
-
-        if selected_larger_symbol {
-            self.change_selections(Some(Autoscroll::fit()), cx, |s| {
-                s.select(new_selections);
-            });
-        }
-    }
-
    pub fn select_larger_syntax_node(
        &mut self,
        _: &SelectLargerSyntaxNode,
@@ -8484,14 +8386,13 @@ impl Editor {
        runnable: &mut Runnable,
        cx: &WindowContext<'_>,
    ) -> Vec<(TaskSourceKind, TaskTemplate)> {
-        let (inventory, worktree_id, file) = project.read_with(cx, |project, cx| {
-            let (worktree_id, file) = project
+        let (inventory, worktree_id) = project.read_with(cx, |project, cx| {
+            let worktree_id = project
                .buffer_for_id(runnable.buffer)
                .and_then(|buffer| buffer.read(cx).file())
-                .map(|file| (WorktreeId::from_usize(file.worktree_id()), file.clone()))
-                .unzip();
+                .map(|file| WorktreeId::from_usize(file.worktree_id()));

-            (project.task_inventory().clone(), worktree_id, file)
+            (project.task_inventory().clone(), worktree_id)
        });

        let inventory = inventory.read(cx);
@@ -8501,12 +8402,7 @@ impl Editor {
            .flat_map(|tag| {
                let tag = tag.0.clone();
                inventory
-                    .list_tasks(
-                        file.clone(),
-                        Some(runnable.language.clone()),
-                        worktree_id,
-                        cx,
-                    )
+                    .list_tasks(Some(runnable.language.clone()), worktree_id)
                    .into_iter()
                    .filter(move |(_, template)| {
                        template.tags.iter().any(|source_tag| source_tag == &tag)
@@ -8847,7 +8743,13 @@ impl Editor {
        let display_point = initial_point.to_display_point(snapshot);
        let mut hunks = hunks
            .map(|hunk| diff_hunk_to_display(&hunk, &snapshot))
-            .filter(|hunk| is_wrapped || !hunk.contains_display_row(display_point.row()))
+            .filter(|hunk| {
+                if is_wrapped {
+                    true
+                } else {
+                    !hunk.contains_display_row(display_point.row())
+                }
+            })
            .dedup();

        if let Some(hunk) = hunks.next() {
@@ -12125,7 +12027,7 @@ impl Render for Editor {
        let settings = ThemeSettings::get_global(cx);

        let text_style = match self.mode {
-            EditorMode::SingleLine { .. } | EditorMode::AutoHeight { .. } => TextStyle {
+            EditorMode::SingleLine | EditorMode::AutoHeight { .. } => TextStyle {
                color: cx.theme().colors().editor_foreground,
                font_family: settings.ui_font.family.clone(),
                font_features: settings.ui_font.features.clone(),
@@ -12154,7 +12056,7 @@ impl Render for Editor {
        };

        let background = match self.mode {
-            EditorMode::SingleLine { .. } => cx.theme().system().transparent,
+            EditorMode::SingleLine => cx.theme().system().transparent,
            EditorMode::AutoHeight { max_lines: _ } => cx.theme().system().transparent,
            EditorMode::Full => cx.theme().colors().editor_background,
        };
@@ -12418,7 +12320,6 @@ impl ViewInputHandler for Editor {
        let font_id = cx.text_system().resolve_font(&style.text.font());
        let font_size = style.text.font_size.to_pixels(cx.rem_size());
        let line_height = style.text.line_height_in_pixels(cx.rem_size());
-
        let em_width = cx
            .text_system()
            .typographic_bounds(font_id, font_size, 'm')
@@ -12546,7 +12447,7 @@ pub fn diagnostic_block_renderer(diagnostic: Diagnostic, _is_valid: bool) -> Ren
        let group_id: SharedString = cx.block_id.to_string().into();

        let mut text_style = cx.text_style().clone();
-        text_style.color = diagnostic_style(diagnostic.severity, cx.theme().status());
+        text_style.color = diagnostic_style(diagnostic.severity, true, cx.theme().status());
        let theme_settings = ThemeSettings::get_global(cx);
        text_style.font_family = theme_settings.buffer_font.family.clone();
        text_style.font_style = theme_settings.buffer_font.style;
@@ -12642,19 +12543,25 @@ pub fn highlight_diagnostic_message(diagnostic: &Diagnostic) -> (SharedString, V
        prev_offset = ix + 1;
        if in_code_block {
            code_ranges.push(prev_len..text_without_backticks.len());
+            in_code_block = false;
+        } else {
+            in_code_block = true;
        }
-        in_code_block = !in_code_block;
    }

    (text_without_backticks.into(), code_ranges)
 }

-fn diagnostic_style(severity: DiagnosticSeverity, colors: &StatusColors) -> Hsla {
-    match severity {
-        DiagnosticSeverity::ERROR => colors.error,
-        DiagnosticSeverity::WARNING => colors.warning,
-        DiagnosticSeverity::INFORMATION => colors.info,
-        DiagnosticSeverity::HINT => colors.info,
+fn diagnostic_style(severity: DiagnosticSeverity, valid: bool, colors: &StatusColors) -> Hsla {
+    match (severity, valid) {
+        (DiagnosticSeverity::ERROR, true) => colors.error,
+        (DiagnosticSeverity::ERROR, false) => colors.error,
+        (DiagnosticSeverity::WARNING, true) => colors.warning,
+        (DiagnosticSeverity::WARNING, false) => colors.warning,
+        (DiagnosticSeverity::INFORMATION, true) => colors.info,
+        (DiagnosticSeverity::INFORMATION, false) => colors.info,
+        (DiagnosticSeverity::HINT, true) => colors.info,
+        (DiagnosticSeverity::HINT, false) => colors.info,
        _ => colors.ignored,
    }
 }
@@ -12724,7 +12631,7 @@ pub(crate) fn split_words(text: &str) -> impl std::iter::Iterator<Item = &str> +
        })
 }

-pub trait RangeToAnchorExt {
+trait RangeToAnchorExt {
    fn to_anchors(self, snapshot: &MultiBufferSnapshot) -> Range<Anchor>;
 }

--- a/crates/editor/src/editor_settings.rs
+++ b/crates/editor/src/editor_settings.rs
@@ -25,8 +25,6 @@ pub struct EditorSettings {
    pub expand_excerpt_lines: u32,
    #[serde(default)]
    pub double_click_in_multibuffer: DoubleClickInMultibuffer,
-    #[serde(default)]
-    pub jupyter: Jupyter,
 }

 #[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
@@ -66,15 +64,6 @@ pub enum DoubleClickInMultibuffer {
    Open,
 }

-#[derive(Default, Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
-#[serde(rename_all = "snake_case")]
-pub struct Jupyter {
-    /// Whether the Jupyter feature is enabled.
-    ///
-    /// Default: `false`
-    pub enabled: bool,
-}
-
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
 pub struct Toolbar {
    pub breadcrumbs: bool,
@@ -228,9 +217,6 @@ pub struct EditorSettingsContent {
    ///
    /// Default: select
    pub double_click_in_multibuffer: Option<DoubleClickInMultibuffer>,
-
-    /// Jupyter REPL settings.
-    pub jupyter: Option<Jupyter>,
 }

 // Toolbar related settings
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -10,8 +10,8 @@ use crate::{
 };
 use futures::StreamExt;
 use gpui::{
-    div, SemanticVersion, TestAppContext, UpdateGlobal, VisualTestContext, WindowBounds,
-    WindowOptions,
+    div, AssetSource, SemanticVersion, TestAppContext, UpdateGlobal, VisualTestContext,
+    WindowBounds, WindowOptions,
 };
 use indoc::indoc;
 use language::{
@@ -7019,73 +7019,6 @@ async fn test_completion(cx: &mut gpui::TestAppContext) {
    apply_additional_edits.await.unwrap();
 }

-#[gpui::test]
-async fn test_completion_page_up_down_keys(cx: &mut gpui::TestAppContext) {
-    init_test(cx, |_| {});
-    let mut cx = EditorLspTestContext::new_rust(
-        lsp::ServerCapabilities {
-            completion_provider: Some(lsp::CompletionOptions {
-                trigger_characters: Some(vec![".".to_string()]),
-                ..Default::default()
-            }),
-            ..Default::default()
-        },
-        cx,
-    )
-    .await;
-    cx.lsp
-        .handle_request::<lsp::request::Completion, _, _>(move |_, _| async move {
-            Ok(Some(lsp::CompletionResponse::Array(vec![
-                lsp::CompletionItem {
-                    label: "first".into(),
-                    ..Default::default()
-                },
-                lsp::CompletionItem {
-                    label: "last".into(),
-                    ..Default::default()
-                },
-            ])))
-        });
-    cx.set_state("variableˇ");
-    cx.simulate_keystroke(".");
-    cx.executor().run_until_parked();
-
-    cx.update_editor(|editor, _| {
-        if let Some(ContextMenu::Completions(menu)) = editor.context_menu.read().as_ref() {
-            assert_eq!(
-                menu.matches.iter().map(|m| &m.string).collect::<Vec<_>>(),
-                &["first", "last"]
-            );
-        } else {
-            panic!("expected completion menu to be open");
-        }
-    });
-
-    cx.update_editor(|editor, cx| {
-        editor.move_page_down(&MovePageDown::default(), cx);
-        if let Some(ContextMenu::Completions(menu)) = editor.context_menu.read().as_ref() {
-            assert!(
-                menu.selected_item == 1,
-                "expected PageDown to select the last item from the context menu"
-            );
-        } else {
-            panic!("expected completion menu to stay open after PageDown");
-        }
-    });
-
-    cx.update_editor(|editor, cx| {
-        editor.move_page_up(&MovePageUp::default(), cx);
-        if let Some(ContextMenu::Completions(menu)) = editor.context_menu.read().as_ref() {
-            assert!(
-                menu.selected_item == 0,
-                "expected PageUp to select the first item from the context menu"
-            );
-        } else {
-            panic!("expected completion menu to stay open after PageUp");
-        }
-    });
-}
-
 #[gpui::test]
 async fn test_no_duplicated_completion_requests(cx: &mut gpui::TestAppContext) {
    init_test(cx, |_| {});
@@ -12556,7 +12489,12 @@ pub(crate) fn update_test_project_settings(

 pub(crate) fn init_test(cx: &mut TestAppContext, f: fn(&mut AllLanguageSettingsContent)) {
    _ = cx.update(|cx| {
-        assets::Assets.load_test_fonts(cx);
+        cx.text_system()
+            .add_fonts(vec![assets::Assets
+                .load("fonts/zed-mono/zed-mono-extended.ttf")
+                .unwrap()
+                .unwrap()])
+            .unwrap();
        let store = SettingsStore::test(cx);
        cx.set_global(store);
        theme::init(theme::LoadThemes::JustBase, cx);
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -276,7 +276,6 @@ impl EditorElement {
        register_action(view, cx, Editor::toggle_comments);
        register_action(view, cx, Editor::select_larger_syntax_node);
        register_action(view, cx, Editor::select_smaller_syntax_node);
-        register_action(view, cx, Editor::select_enclosing_symbol);
        register_action(view, cx, Editor::move_to_enclosing_bracket);
        register_action(view, cx, Editor::undo_selection);
        register_action(view, cx, Editor::redo_selection);
@@ -1119,12 +1118,11 @@ impl EditorElement {
            ScrollBeyondLastLine::Off => 1.0,
            ScrollBeyondLastLine::VerticalScrollMargin => 1.0 + settings.vertical_scroll_margin,
        };
-        let total_rows =
-            (snapshot.max_point().row().as_f32() + scroll_beyond_last_line).max(rows_per_page);
+        let total_rows = snapshot.max_point().row().as_f32() + scroll_beyond_last_line;
        let height = bounds.size.height;
        let px_per_row = height / total_rows;
        let thumb_height = (rows_per_page * px_per_row).max(ScrollbarLayout::MIN_THUMB_HEIGHT);
-        let row_height = (height - thumb_height) / (total_rows - rows_per_page).max(0.);
+        let row_height = (height - thumb_height) / (total_rows - rows_per_page).max(0.0);

        Some(ScrollbarLayout {
            hitbox: cx.insert_hitbox(track_bounds, false),
@@ -1832,10 +1830,10 @@ impl EditorElement {
    }

    fn layout_lines(
+        &self,
        rows: Range<DisplayRow>,
        line_number_layouts: &[Option<ShapedLine>],
        snapshot: &EditorSnapshot,
-        style: &EditorStyle,
        cx: &mut WindowContext,
    ) -> Vec<LineWithInvisibles> {
        if rows.start >= rows.end {
@@ -1844,7 +1842,7 @@ impl EditorElement {

        // Show the placeholder when the editor is empty
        if snapshot.is_empty() {
-            let font_size = style.text.font_size.to_pixels(cx.rem_size());
+            let font_size = self.style.text.font_size.to_pixels(cx.rem_size());
            let placeholder_color = cx.theme().colors().text_placeholder;
            let placeholder_text = snapshot.placeholder_text();

@@ -1859,7 +1857,7 @@ impl EditorElement {
                .filter_map(move |line| {
                    let run = TextRun {
                        len: line.len(),
-                        font: style.text.font(),
+                        font: self.style.text.font(),
                        color: placeholder_color,
                        background_color: None,
                        underline: Default::default(),
@@ -1878,10 +1876,10 @@ impl EditorElement {
                })
                .collect()
        } else {
-            let chunks = snapshot.highlighted_chunks(rows.clone(), true, style);
+            let chunks = snapshot.highlighted_chunks(rows.clone(), true, &self.style);
            LineWithInvisibles::from_chunks(
                chunks,
-                &style.text,
+                &self.style.text,
                MAX_LINE_LEN,
                rows.len(),
                line_number_layouts,
@@ -4476,7 +4474,7 @@ impl EditorElement {
            // We currently use single-line and auto-height editors in UI contexts,
            // so we don't want to scale everything with the buffer font size, as it
            // ends up looking off.
-            EditorMode::SingleLine { .. } | EditorMode::AutoHeight { .. } => None,
+            EditorMode::SingleLine | EditorMode::AutoHeight { .. } => None,
        }
    }
 }
@@ -4500,43 +4498,12 @@ impl Element for EditorElement {
                editor.set_style(self.style.clone(), cx);

                let layout_id = match editor.mode {
-                    EditorMode::SingleLine { auto_width } => {
+                    EditorMode::SingleLine => {
                        let rem_size = cx.rem_size();
-
-                        let height = self.style.text.line_height_in_pixels(rem_size);
-                        if auto_width {
-                            let editor_handle = cx.view().clone();
-                            let style = self.style.clone();
-                            cx.request_measured_layout(Style::default(), move |_, _, cx| {
-                                let editor_snapshot =
-                                    editor_handle.update(cx, |editor, cx| editor.snapshot(cx));
-                                let line = Self::layout_lines(
-                                    DisplayRow(0)..DisplayRow(1),
-                                    &[],
-                                    &editor_snapshot,
-                                    &style,
-                                    cx,
-                                )
-                                .pop()
-                                .unwrap();
-
-                                let font_id = cx.text_system().resolve_font(&style.text.font());
-                                let font_size = style.text.font_size.to_pixels(cx.rem_size());
-                                let em_width = cx
-                                    .text_system()
-                                    .typographic_bounds(font_id, font_size, 'm')
-                                    .unwrap()
-                                    .size
-                                    .width;
-
-                                size(line.width + em_width, height)
-                            })
-                        } else {
-                            let mut style = Style::default();
-                            style.size.height = height.into();
-                            style.size.width = relative(1.).into();
-                            cx.request_layout(style, None)
-                        }
+                        let mut style = Style::default();
+                        style.size.width = relative(1.).into();
+                        style.size.height = self.style.text.line_height_in_pixels(rem_size).into();
+                        cx.request_layout(style, None)
                    }
                    EditorMode::AutoHeight { max_lines } => {
                        let editor_handle = cx.view().clone();
@@ -4677,17 +4644,17 @@ impl Element for EditorElement {
                        text_hitbox.origin + point(gutter_dimensions.margin, Pixels::ZERO);

                    let height_in_lines = bounds.size.height / line_height;
-                    let max_row = snapshot.max_point().row().as_f32();
                    let max_scroll_top = if matches!(snapshot.mode, EditorMode::AutoHeight { .. }) {
-                        (max_row - height_in_lines + 1.).max(0.)
+                        (snapshot.max_point().row().as_f32() - height_in_lines + 1.).max(0.)
                    } else {
                        let settings = EditorSettings::get_global(cx);
+                        let max_row = snapshot.max_point().row().as_f32();
                        match settings.scroll_beyond_last_line {
                            ScrollBeyondLastLine::OnePage => max_row,
-                            ScrollBeyondLastLine::Off => (max_row - height_in_lines + 1.).max(0.),
+                            ScrollBeyondLastLine::Off => (max_row - height_in_lines + 1.0).max(0.0),
                            ScrollBeyondLastLine::VerticalScrollMargin => {
-                                (max_row - height_in_lines + 1. + settings.vertical_scroll_margin)
-                                    .max(0.)
+                                (max_row - height_in_lines + 1.0 + settings.vertical_scroll_margin)
+                                    .max(0.0)
                            }
                        }
                    };
@@ -4795,13 +4762,8 @@ impl Element for EditorElement {
                    );

                    let mut max_visible_line_width = Pixels::ZERO;
-                    let mut line_layouts = Self::layout_lines(
-                        start_row..end_row,
-                        &line_numbers,
-                        &snapshot,
-                        &self.style,
-                        cx,
-                    );
+                    let mut line_layouts =
+                        self.layout_lines(start_row..end_row, &line_numbers, &snapshot, cx);
                    for line_with_invisibles in &line_layouts {
                        if line_with_invisibles.width > max_visible_line_width {
                            max_visible_line_width = line_with_invisibles.width;
@@ -4829,43 +4791,16 @@ impl Element for EditorElement {
                        )
                    });

-                    let start_buffer_row =
-                        MultiBufferRow(start_anchor.to_point(&snapshot.buffer_snapshot).row);
-                    let end_buffer_row =
-                        MultiBufferRow(end_anchor.to_point(&snapshot.buffer_snapshot).row);
-
-                    let scroll_max = point(
-                        ((scroll_width - text_hitbox.size.width) / em_width).max(0.0),
-                        max_row.as_f32(),
-                    );
-
-                    self.editor.update(cx, |editor, cx| {
-                        let clamped = editor.scroll_manager.clamp_scroll_left(scroll_max.x);
-
-                        let autoscrolled = if autoscroll_horizontally {
-                            editor.autoscroll_horizontally(
-                                start_row,
-                                text_hitbox.size.width,
-                                scroll_width,
-                                em_width,
-                                &line_layouts,
-                                cx,
-                            )
-                        } else {
-                            false
-                        };
-
-                        if clamped || autoscrolled {
-                            snapshot = editor.snapshot(cx);
-                            scroll_position = snapshot.scroll_position();
-                        }
-                    });
-
                    let scroll_pixel_position = point(
                        scroll_position.x * em_width,
                        scroll_position.y * line_height,
                    );

+                    let start_buffer_row =
+                        MultiBufferRow(start_anchor.to_point(&snapshot.buffer_snapshot).row);
+                    let end_buffer_row =
+                        MultiBufferRow(end_anchor.to_point(&snapshot.buffer_snapshot).row);
+
                    let indent_guides = self.layout_indent_guides(
                        content_origin,
                        text_hitbox.origin,
@@ -6129,7 +6064,7 @@ mod tests {
        });

        for editor_mode_without_invisibles in [
-            EditorMode::SingleLine { auto_width: false },
+            EditorMode::SingleLine,
            EditorMode::AutoHeight { max_lines: 100 },
        ] {
            let invisibles = collect_invisibles_from_new_editor(
--- a/crates/editor/src/indent_guides.rs
+++ b/crates/editor/src/indent_guides.rs
@@ -165,16 +165,10 @@ pub fn indent_guides_in_range(
        .indent_guides_in_range(start_anchor..end_anchor, ignore_disabled_for_language, cx)
        .into_iter()
        .filter(|indent_guide| {
-            let start =
-                MultiBufferRow(indent_guide.multibuffer_row_range.start.0.saturating_sub(1));
            // Filter out indent guides that are inside a fold
-            let is_folded = snapshot.is_line_folded(start);
-            let line_indent = snapshot.line_indent_for_buffer_row(start);
-
-            let contained_in_fold =
-                line_indent.len(indent_guide.tab_size) <= indent_guide.indent_level();
-
-            !(is_folded && contained_in_fold)
+            !snapshot.is_line_folded(MultiBufferRow(
+                indent_guide.multibuffer_row_range.start.0.saturating_sub(1),
+            ))
        })
        .collect()
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Nathan Sobo	488e32ec89	Write a rustdoc2md example binary to explore markdown generation	2024-06-24 16:08:58 -06:00
Nathan Sobo	4b0e429607	Add output offsets for items, CLI example to test	2024-06-24 15:53:20 -06:00
				`@@ -1 +0,0 @@`
				`<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-book"><path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H20v20H6.5a2.5 2.5 0 0 1 0-5H20"/></svg>`