pass through remote kernel's language on legacy selection

Overhaul extension registration (#21083 )
This PR overhauls extension registration in order to make it more modular. The `extension` crate now contains an `ExtensionHostProxy` that can be used to register various proxies that the extension host can use to interact with the rest of the system. There are now a number of different proxy traits representing the various pieces of functionality that can be provided by an extension. The respective crates that provide this functionality can implement their corresponding proxy trait in order to register a proxy that the extension host will use to register the bits of functionality provided by the extension. Release Notes: - N/A
2024-11-22 16:18:18 -08:00 · 2024-11-22 19:02:32 -05:00 · 2024-11-22 16:03:46 -07:00 · 2024-11-22 14:59:40 -08:00 · 2024-11-22 17:50:25 -05:00 · 2024-11-22 14:49:26 -08:00
390 changed files with 14635 additions and 7131 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -245,6 +245,7 @@ jobs:
          # 25 was chosen arbitrarily.
          fetch-depth: 25
          clean: false
+          ref: ${{ github.ref }}

      - name: Limit target directory size
        run: script/clear-target-dir-if-larger-than 100
@@ -261,6 +262,9 @@ jobs:
          mkdir -p target/
          # Ignore any errors that occur while drafting release notes to not fail the build.
          script/draft-release-notes "$RELEASE_VERSION" "$RELEASE_CHANNEL" > target/release-notes.md || true
+          script/create-draft-release target/release-notes.md
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - name: Generate license file
        run: script/generate-licenses
@@ -268,18 +272,12 @@ jobs:
      - name: Create macOS app bundle
        run: script/bundle-mac

-      - name: Rename single-architecture binaries
+      - name: Rename binaries
        if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
        run: |
          mv target/aarch64-apple-darwin/release/Zed.dmg target/aarch64-apple-darwin/release/Zed-aarch64.dmg
          mv target/x86_64-apple-darwin/release/Zed.dmg target/x86_64-apple-darwin/release/Zed-x86_64.dmg

-      - name: Upload app bundle (universal) to workflow run if main branch or specific label
-        uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882 # v4
-        if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
-        with:
-          name: Zed_${{ github.event.pull_request.head.sha || github.sha }}.dmg
-          path: target/release/Zed.dmg
      - name: Upload app bundle (aarch64) to workflow run if main branch or specific label
        uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882 # v4
        if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
@@ -305,8 +303,6 @@ jobs:
            target/zed-remote-server-macos-aarch64.gz
            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
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

@@ -353,7 +349,6 @@ jobs:
          files: |
            target/zed-remote-server-linux-x86_64.gz
            target/release/zed-linux-x86_64.tar.gz
-          body: ""
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

@@ -400,6 +395,18 @@ jobs:
          files: |
            target/zed-remote-server-linux-aarch64.gz
            target/release/zed-linux-aarch64.tar.gz
-          body: ""
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  auto-release-preview:
+    name: Auto release preview
+    if: ${{ startsWith(github.ref, 'refs/tags/v') && endsWith(github.ref, '-pre') && !endsWith(github.ref, '.0-pre') }}
+    needs: [bundle-mac, bundle-linux, bundle-linux-aarch64]
+    runs-on:
+      - self-hosted
+      - bundle
+    steps:
+      - name: gh release
+        run: gh release edit $GITHUB_REF_NAME --draft=false
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/.github/workflows/script_checks.yml
+++ b/.github/workflows/script_checks.yml
@@ -0,0 +1,21 @@
+name: Script
+
+on:
+  pull_request:
+    paths:
+      - "script/**"
+  push:
+    branches:
+      - main
+
+jobs:
+  shellcheck:
+    name: "ShellCheck Scripts"
+    if: github.repository_owner == 'zed-industries'
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - name: Shellcheck ./scripts
+        run: |
+          ./script/shellcheck-scripts error
--- a/.mailmap
+++ b/.mailmap
@@ -22,10 +22,14 @@ Antonio Scandurra <me@as-cii.com> <antonio@zed.dev>
 Bennet Bo Fenner <bennet@zed.dev>
 Bennet Bo Fenner <bennet@zed.dev> <53836821+bennetbo@users.noreply.github.com>
 Bennet Bo Fenner <bennet@zed.dev> <bennetbo@gmx.de>
+Boris Cherny <boris@anthropic.com>
+Boris Cherny <boris@anthropic.com> <boris@performancejs.com>
+Chris Hayes <chris+git@hayes.software>
 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>
+Dairon Medina <dairon.medina@gmail.com>
 Danilo Leal <danilo@zed.dev>
 Danilo Leal <danilo@zed.dev> <67129314+danilo-leal@users.noreply.github.com>
 Evren Sen <nervenes@icloud.com>
@@ -35,6 +39,7 @@ Fernando Tagawa <tagawafernando@gmail.com>
 Fernando Tagawa <tagawafernando@gmail.com> <fernando.tagawa.gamail.com@gmail.com>
 Greg Morenz <greg-morenz@droid.cafe>
 Greg Morenz <greg-morenz@droid.cafe> <morenzg@gmail.com>
+Ihnat Aŭtuška <autushka.ihnat@gmail.com>
 Ivan Žužak <izuzak@gmail.com>
 Ivan Žužak <izuzak@gmail.com> <ivan.zuzak@github.com>
 Joseph T. Lyons <JosephTLyons@gmail.com>
@@ -61,10 +66,13 @@ Max Brunsfeld <maxbrunsfeld@gmail.com> <max@zed.dev>
 Max Linke <maxlinke88@gmail.com>
 Max Linke <maxlinke88@gmail.com> <kain88-de@users.noreply.github.com>
 Michael Sloan <michael@zed.dev>
+Michael Sloan <michael@zed.dev> <mgsloan@gmail.com>
 Michael Sloan <michael@zed.dev> <mgsloan@google.com>
 Mikayla Maki <mikayla@zed.dev>
 Mikayla Maki <mikayla@zed.dev> <mikayla.c.maki@gmail.com>
 Mikayla Maki <mikayla@zed.dev> <mikayla.c.maki@icloud.com>
+Muhammad Talal Anwar <mail@talal.io>
+Muhammad Talal Anwar <mail@talal.io> <talalanwar@outlook.com>
 Nate Butler <iamnbutler@gmail.com>
 Nate Butler <iamnbutler@gmail.com> <nate@zed.dev>
 Nathan Sobo <nathan@zed.dev>
@@ -88,7 +96,11 @@ Robert Clover <git@clo4.net>
 Robert Clover <git@clo4.net> <robert@clover.gdn>
 Roy Williams <roy.williams.iii@gmail.com>
 Roy Williams <roy.williams.iii@gmail.com> <roy@anthropic.com>
+Sebastijan Kelnerič <sebastijan.kelneric@sebba.dev>
+Sebastijan Kelnerič <sebastijan.kelneric@sebba.dev> <sebastijan.kelneric@vichava.com>
 Sergey Onufrienko <sergey@onufrienko.com>
+Shish <webmaster@shishnet.org>
+Shish <webmaster@shishnet.org> <shish@shishnet.org>
 Thorben Kröger <dev@thorben.net>
 Thorben Kröger <dev@thorben.net> <thorben.kroeger@hexagon.com>
 Thorsten Ball <thorsten@zed.dev>
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,6 +9,7 @@ members = [
    "crates/assistant_tool",
    "crates/audio",
    "crates/auto_update",
+    "crates/auto_update_ui",
    "crates/breadcrumbs",
    "crates/call",
    "crates/channel",
@@ -49,11 +50,14 @@ members = [
    "crates/http_client",
    "crates/image_viewer",
    "crates/indexed_docs",
+    "crates/inline_completion",
    "crates/inline_completion_button",
    "crates/install_cli",
    "crates/journal",
    "crates/language",
+    "crates/language_extension",
    "crates/language_model",
+    "crates/language_models",
    "crates/language_selector",
    "crates/language_tools",
    "crates/languages",
@@ -78,7 +82,6 @@ members = [
    "crates/project_panel",
    "crates/project_symbols",
    "crates/proto",
-    "crates/quick_action_bar",
    "crates/recent_projects",
    "crates/refineable",
    "crates/refineable/derive_refineable",
@@ -114,6 +117,7 @@ members = [
    "crates/terminal_view",
    "crates/text",
    "crates/theme",
+    "crates/theme_extension",
    "crates/theme_importer",
    "crates/theme_selector",
    "crates/time_format",
@@ -126,6 +130,7 @@ members = [
    "crates/util",
    "crates/vcs_menu",
    "crates/vim",
+    "crates/vim_mode_setting",
    "crates/welcome",
    "crates/workspace",
    "crates/worktree",
@@ -148,7 +153,6 @@ members = [
    "extensions/haskell",
    "extensions/html",
    "extensions/lua",
-    "extensions/ocaml",
    "extensions/php",
    "extensions/perplexity",
    "extensions/prisma",
@@ -186,6 +190,7 @@ assistant_slash_command = { path = "crates/assistant_slash_command" }
 assistant_tool = { path = "crates/assistant_tool" }
 audio = { path = "crates/audio" }
 auto_update = { path = "crates/auto_update" }
+auto_update_ui = { path = "crates/auto_update_ui" }
 breadcrumbs = { path = "crates/breadcrumbs" }
 call = { path = "crates/call" }
 channel = { path = "crates/channel" }
@@ -222,11 +227,14 @@ html_to_markdown = { path = "crates/html_to_markdown" }
 http_client = { path = "crates/http_client" }
 image_viewer = { path = "crates/image_viewer" }
 indexed_docs = { path = "crates/indexed_docs" }
+inline_completion = { path = "crates/inline_completion" }
 inline_completion_button = { path = "crates/inline_completion_button" }
 install_cli = { path = "crates/install_cli" }
 journal = { path = "crates/journal" }
 language = { path = "crates/language" }
+language_extension = { path = "crates/language_extension" }
 language_model = { path = "crates/language_model" }
+language_models = { path = "crates/language_models" }
 language_selector = { path = "crates/language_selector" }
 language_tools = { path = "crates/language_tools" }
 languages = { path = "crates/languages" }
@@ -253,7 +261,6 @@ project = { path = "crates/project" }
 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" }
 refineable = { path = "crates/refineable" }
 release_channel = { path = "crates/release_channel" }
@@ -288,6 +295,7 @@ terminal = { path = "crates/terminal" }
 terminal_view = { path = "crates/terminal_view" }
 text = { path = "crates/text" }
 theme = { path = "crates/theme" }
+theme_extension = { path = "crates/theme_extension" }
 theme_importer = { path = "crates/theme_importer" }
 theme_selector = { path = "crates/theme_selector" }
 time_format = { path = "crates/time_format" }
@@ -299,6 +307,7 @@ ui_macros = { path = "crates/ui_macros" }
 util = { path = "crates/util" }
 vcs_menu = { path = "crates/vcs_menu" }
 vim = { path = "crates/vim" }
+vim_mode_setting = { path = "crates/vim_mode_setting" }
 welcome = { path = "crates/welcome" }
 workspace = { path = "crates/workspace" }
 worktree = { path = "crates/worktree" }
@@ -333,7 +342,7 @@ blade-macros = { git = "https://github.com/kvark/blade", rev = "e142a3a5e678eb6a
 blade-util = { git = "https://github.com/kvark/blade", rev = "e142a3a5e678eb6a13e642ad8401b1f3aa38e969" }
 blake3 = "1.5.3"
 bytes = "1.0"
-cargo_metadata = "0.18"
+cargo_metadata = "0.19"
 cargo_toml = "0.20"
 chrono = { version = "0.4", features = ["serde"] }
 clap = { version = "4.4", features = ["derive"] }
@@ -369,12 +378,14 @@ indexmap = { version = "1.6.2", features = ["serde"] }
 indoc = "2"
 itertools = "0.13.0"
 jsonwebtoken = "9.3"
+jupyter-protocol = { version = "0.2.0" }
+jupyter-websocket-client = { version = "0.4.1" }
 libc = "0.2"
 linkify = "0.10.0"
 log = { version = "0.4.16", features = ["kv_unstable_serde", "serde"] }
 markup5ever_rcdom = "0.3.0"
 nanoid = "0.4"
-nbformat = "0.5.0"
+nbformat = "0.6.0"
 nix = "0.29"
 num-format = "0.4.4"
 once_cell = "1.19.0"
@@ -389,7 +400,7 @@ pet-core = { git = "https://github.com/microsoft/python-environment-tools.git",
 pet-poetry = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "ffcbf3f28c46633abd5448a52b1f396c322e0d6c"  }
 pet-reporter = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "ffcbf3f28c46633abd5448a52b1f396c322e0d6c"  }
 postage = { version = "0.5", features = ["futures-traits"] }
-pretty_assertions = "1.3.0"
+pretty_assertions = { version = "1.3.0", features = ["unstable"] }
 profiling = "1"
 prost = "0.9"
 prost-build = "0.9"
@@ -408,7 +419,7 @@ reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "fd110f
    "stream",
 ] }
 rsa = "0.9.6"
-runtimelib = { version = "0.19.0", default-features = false, features = [
+runtimelib = { version = "0.21.0", default-features = false, features = [
    "async-dispatcher-runtime",
 ] }
 rustc-demangle = "0.1.23"
@@ -563,45 +574,45 @@ ttf-parser = { opt-level = 3 }
 wasmtime-cranelift = { opt-level = 3 }
 wasmtime = { opt-level = 3 }
 # Build single-source-file crates with cg=1 as it helps make `cargo build` of a whole workspace a bit faster
-activity_indicator = {codegen-units = 1}
-assets = {codegen-units = 1}
-breadcrumbs = {codegen-units = 1}
-collections = {codegen-units = 1}
-command_palette = {codegen-units = 1}
-command_palette_hooks = {codegen-units = 1}
-evals = {codegen-units = 1}
-extension_cli = {codegen-units = 1}
-feature_flags = {codegen-units = 1}
-file_icons = {codegen-units = 1}
-fsevent = {codegen-units = 1}
-image_viewer = {codegen-units = 1}
-inline_completion_button = {codegen-units = 1}
-install_cli = {codegen-units = 1}
-journal = {codegen-units = 1}
-menu = {codegen-units = 1}
-notifications = {codegen-units = 1}
-ollama = {codegen-units = 1}
-outline = {codegen-units = 1}
-paths = {codegen-units = 1}
-prettier = {codegen-units = 1}
-project_symbols = {codegen-units = 1}
-refineable = {codegen-units = 1}
-release_channel = {codegen-units = 1}
-reqwest_client = {codegen-units = 1}
-rich_text = {codegen-units = 1}
-semantic_version = {codegen-units = 1}
-session = {codegen-units = 1}
-snippet = {codegen-units = 1}
-snippets_ui = {codegen-units = 1}
-sqlez_macros = {codegen-units = 1}
-story = {codegen-units = 1}
-supermaven_api = {codegen-units = 1}
-telemetry_events = {codegen-units = 1}
-theme_selector = {codegen-units = 1}
-time_format = {codegen-units = 1}
-ui_input = {codegen-units = 1}
-vcs_menu = {codegen-units = 1}
-zed_actions = {codegen-units = 1}
+activity_indicator = { codegen-units = 1 }
+assets = { codegen-units = 1 }
+breadcrumbs = { codegen-units = 1 }
+collections = { codegen-units = 1 }
+command_palette = { codegen-units = 1 }
+command_palette_hooks = { codegen-units = 1 }
+evals = { codegen-units = 1 }
+extension_cli = { codegen-units = 1 }
+feature_flags = { codegen-units = 1 }
+file_icons = { codegen-units = 1 }
+fsevent = { codegen-units = 1 }
+image_viewer = { codegen-units = 1 }
+inline_completion_button = { codegen-units = 1 }
+install_cli = { codegen-units = 1 }
+journal = { codegen-units = 1 }
+menu = { codegen-units = 1 }
+notifications = { codegen-units = 1 }
+ollama = { codegen-units = 1 }
+outline = { codegen-units = 1 }
+paths = { codegen-units = 1 }
+prettier = { codegen-units = 1 }
+project_symbols = { codegen-units = 1 }
+refineable = { codegen-units = 1 }
+release_channel = { codegen-units = 1 }
+reqwest_client = { codegen-units = 1 }
+rich_text = { codegen-units = 1 }
+semantic_version = { codegen-units = 1 }
+session = { codegen-units = 1 }
+snippet = { codegen-units = 1 }
+snippets_ui = { codegen-units = 1 }
+sqlez_macros = { codegen-units = 1 }
+story = { codegen-units = 1 }
+supermaven_api = { codegen-units = 1 }
+telemetry_events = { codegen-units = 1 }
+theme_selector = { codegen-units = 1 }
+time_format = { codegen-units = 1 }
+ui_input = { codegen-units = 1 }
+vcs_menu = { codegen-units = 1 }
+zed_actions = { codegen-units = 1 }

 [profile.release]
 debug = "limited"
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -251,6 +251,8 @@
      "ctrl-pagedown": "pane::ActivateNextItem",
      "ctrl-shift-pageup": "pane::SwapItemLeft",
      "ctrl-shift-pagedown": "pane::SwapItemRight",
+      "back": "pane::GoBack",
+      "forward": "pane::GoForward",
      "ctrl-w": "pane::CloseActiveItem",
      "ctrl-f4": "pane::CloseActiveItem",
      "alt-ctrl-t": ["pane::CloseInactiveItems", { "close_pinned": false }],
@@ -648,19 +650,23 @@
    }
  },
  {
-    "context": "FileFinder",
+    "context": "FileFinder && !menu_open",
    "bindings": {
      "ctrl-shift-p": "file_finder::SelectPrev",
-      "ctrl-k": "file_finder::OpenMenu"
+      "ctrl": "file_finder::OpenMenu",
+      "ctrl-j": "pane::SplitDown",
+      "ctrl-k": "pane::SplitUp",
+      "ctrl-h": "pane::SplitLeft",
+      "ctrl-l": "pane::SplitRight"
    }
  },
  {
    "context": "FileFinder && menu_open",
    "bindings": {
-      "u": "pane::SplitUp",
-      "d": "pane::SplitDown",
-      "l": "pane::SplitLeft",
-      "r": "pane::SplitRight"
+      "j": "pane::SplitDown",
+      "k": "pane::SplitUp",
+      "h": "pane::SplitLeft",
+      "l": "pane::SplitRight"
    }
  },
  {
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -49,8 +49,9 @@
      "ctrl-d": "editor::Delete",
      "tab": "editor::Tab",
      "shift-tab": "editor::TabPrev",
-      "ctrl-k": "editor::CutToEndOfLine",
      "ctrl-t": "editor::Transpose",
+      "ctrl-k": "editor::KillRingCut",
+      "ctrl-y": "editor::KillRingYank",
      "cmd-k q": "editor::Rewrap",
      "cmd-k cmd-q": "editor::Rewrap",
      "cmd-backspace": "editor::DeleteToBeginningOfLine",
@@ -92,6 +93,8 @@
      "ctrl-e": "editor::MoveToEndOfLine",
      "cmd-up": "editor::MoveToBeginning",
      "cmd-down": "editor::MoveToEnd",
+      "ctrl-home": "editor::MoveToBeginning",
+      "ctrl-end": "editor::MoveToEnd",
      "shift-up": "editor::SelectUp",
      "ctrl-shift-p": "editor::SelectUp",
      "shift-down": "editor::SelectDown",
@@ -648,19 +651,23 @@
    }
  },
  {
-    "context": "FileFinder",
+    "context": "FileFinder && !menu_open",
    "bindings": {
      "cmd-shift-p": "file_finder::SelectPrev",
-      "cmd-k": "file_finder::OpenMenu"
+      "cmd": "file_finder::OpenMenu",
+      "cmd-j": "pane::SplitDown",
+      "cmd-k": "pane::SplitUp",
+      "cmd-h": "pane::SplitLeft",
+      "cmd-l": "pane::SplitRight"
    }
  },
  {
    "context": "FileFinder && menu_open",
    "bindings": {
-      "u": "pane::SplitUp",
-      "d": "pane::SplitDown",
-      "l": "pane::SplitLeft",
-      "r": "pane::SplitRight"
+      "j": "pane::SplitDown",
+      "k": "pane::SplitUp",
+      "h": "pane::SplitLeft",
+      "l": "pane::SplitRight"
    }
  },
  {
--- a/assets/keymaps/linux/sublime_text.json
+++ b/assets/keymaps/linux/sublime_text.json
@@ -4,9 +4,7 @@
      "ctrl-shift-[": "pane::ActivatePrevItem",
      "ctrl-shift-]": "pane::ActivateNextItem",
      "ctrl-pageup": "pane::ActivatePrevItem",
-      "ctrl-pagedown": "pane::ActivateNextItem",
-      "ctrl-tab": "pane::ActivateNextItem",
-      "ctrl-shift-tab": "pane::ActivatePrevItem"
+      "ctrl-pagedown": "pane::ActivateNextItem"
    }
  },
  {
@@ -18,6 +16,7 @@
      "ctrl-shift-l": "editor::SplitSelectionIntoLines",
      "ctrl-shift-a": "editor::SelectLargerSyntaxNode",
      "ctrl-shift-d": "editor::DuplicateLineDown",
+      "alt-f3": "editor::SelectAllMatches", // find_all_under
      "f12": "editor::GoToDefinition",
      "ctrl-f12": "editor::GoToDefinitionSplit",
      "shift-f12": "editor::FindAllReferences",
--- a/assets/keymaps/macos/sublime_text.json
+++ b/assets/keymaps/macos/sublime_text.json
@@ -4,9 +4,7 @@
      "cmd-shift-[": "pane::ActivatePrevItem",
      "cmd-shift-]": "pane::ActivateNextItem",
      "ctrl-pageup": "pane::ActivatePrevItem",
-      "ctrl-pagedown": "pane::ActivateNextItem",
-      "ctrl-tab": "pane::ActivateNextItem",
-      "ctrl-shift-tab": "pane::ActivatePrevItem"
+      "ctrl-pagedown": "pane::ActivateNextItem"
    }
  },
  {
@@ -21,6 +19,7 @@
      "cmd-shift-l": "editor::SplitSelectionIntoLines",
      "cmd-shift-a": "editor::SelectLargerSyntaxNode",
      "cmd-shift-d": "editor::DuplicateLineDown",
+      "ctrl-cmd-g": "editor::SelectAllMatches", // find_all_under
      "shift-f12": "editor::FindAllReferences",
      "alt-cmd-down": "editor::GoToDefinition",
      "ctrl-alt-cmd-down": "editor::GoToDefinitionSplit",
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -381,8 +381,7 @@
      "shift-b": "vim::CurlyBrackets",
      "<": "vim::AngleBrackets",
      ">": "vim::AngleBrackets",
-      "a": "vim::AngleBrackets",
-      "g": "vim::Argument"
+      "a": "vim::Argument"
    }
  },
  {
@@ -578,7 +577,7 @@
    }
  },
  {
-    "context": "EmptyPane || SharedScreen || MarkdownPreview || KeyContextView",
+    "context": "EmptyPane || SharedScreen || MarkdownPreview || KeyContextView || Welcome",
    "use_layout_keys": true,
    "bindings": {
      ":": "command_palette::Toggle",
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -157,7 +157,7 @@
  "auto_signature_help": false,
  /// Whether to show the signature help after completion or a bracket pair inserted.
  /// If `auto_signature_help` is enabled, this setting will be treated as enabled also.
-  "show_signature_help_after_edits": true,
+  "show_signature_help_after_edits": false,
  // Whether to show wrap guides (vertical rulers) in the editor.
  // Setting this to true will show a guide at the 'preferred_line_length' value
  // if 'soft_wrap' is set to 'preferred_line_length', and will show any
@@ -490,6 +490,9 @@
    "version": "2",
    // Whether the assistant is enabled.
    "enabled": true,
+    // Whether to show inline hints showing the keybindings to use the inline assistant and the
+    // assistant panel.
+    "show_hints": true,
    // Whether to show the assistant panel button in the status bar.
    "button": true,
    // Where to dock the assistant panel. Can be 'left', 'right' or 'bottom'.
@@ -580,7 +583,23 @@
  // Settings related to the file finder.
  "file_finder": {
    // Whether to show file icons in the file finder.
-    "file_icons": true
+    "file_icons": true,
+    // Determines how much space the file finder can take up in relation to the available window width.
+    // There are 5 possible width values:
+    //
+    // 1. Small: This value is essentially a fixed width.
+    //    "modal_width": "small"
+    // 2. Medium:
+    //    "modal_width": "medium"
+    // 3. Large:
+    //    "modal_width": "large"
+    // 4. Extra Large:
+    //    "modal_width": "xlarge"
+    // 5. Fullscreen: This value removes any horizontal padding, as it consumes the whole viewport width.
+    //    "modal_width": "full"
+    //
+    // Default: small
+    "modal_max_width": "small"
  },
  // Whether or not to remove any trailing whitespace from lines of a buffer
  // before saving it.
@@ -649,7 +668,7 @@
  },
  // Add files or globs of files that will be excluded by Zed entirely:
  // they will be skipped during FS scan(s), file tree and file search
-  // will lack the corresponding file entries.
+  // will lack the corresponding file entries. Overrides `file_scan_inclusions`.
  "file_scan_exclusions": [
    "**/.git",
    "**/.svn",
@@ -660,6 +679,11 @@
    "**/.classpath",
    "**/.settings"
  ],
+  // Add files or globs of files that will be included by Zed, even when
+  // ignored by git. This is useful for files that are not tracked by git,
+  // but are still important to your project. Note that globs that are
+  // overly broad can slow down Zed's file scanning. Overridden by `file_scan_exclusions`.
+  "file_scan_inclusions": [".env*"],
  // Git gutter behavior configuration.
  "git": {
    // Control whether the git gutter is shown. May take 2 values:
@@ -820,8 +844,12 @@
      }
    },
    "toolbar": {
-      // Whether to display the terminal title in its toolbar.
-      "title": true
+      // Whether to display the terminal title in its toolbar's breadcrumbs.
+      // Only shown if the terminal title is not empty.
+      //
+      // The shell running in the terminal needs to be configured to emit the title.
+      // Example: `echo -e "\e]2;New Title\007";`
+      "breadcrumbs": true
    }
    // Set the terminal's font size. If this option is not included,
    // the terminal will default to matching the buffer's font size.
@@ -857,15 +885,8 @@
  //
  "file_types": {
    "Plain Text": ["txt"],
-    "JSON": ["flake.lock"],
-    "JSONC": [
-      "**/.zed/**/*.json",
-      "**/zed/**/*.json",
-      "**/Zed/**/*.json",
-      "tsconfig.json",
-      "pyrightconfig.json"
-    ],
-    "TOML": ["uv.lock"]
+    "JSONC": ["**/.zed/**/*.json", "**/zed/**/*.json", "**/Zed/**/*.json"],
+    "Shell Script": [".env.*"]
  },
  /// By default use a recent system version of node, or install our own.
  /// You can override this to use a version of node that is not in $PATH with:
@@ -1053,13 +1074,11 @@
      "api_url": "https://generativelanguage.googleapis.com"
    },
    "ollama": {
-      "api_url": "http://localhost:11434",
-      "low_speed_timeout_in_seconds": 60
+      "api_url": "http://localhost:11434"
    },
    "openai": {
      "version": "1",
-      "api_url": "https://api.openai.com/v1",
-      "low_speed_timeout_in_seconds": 600
+      "api_url": "https://api.openai.com/v1"
    }
  },
  // Zed's Prettier integration settings.
--- a/crates/anthropic/src/anthropic.rs
+++ b/crates/anthropic/src/anthropic.rs
@@ -1,13 +1,12 @@
 mod supported_countries;

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

 use anyhow::{anyhow, Context, Result};
 use chrono::{DateTime, Utc};
 use futures::{io::BufReader, stream::BoxStream, AsyncBufReadExt, AsyncReadExt, Stream, StreamExt};
 use http_client::http::{HeaderMap, HeaderValue};
-use http_client::{AsyncBody, HttpClient, HttpRequestExt, Method, Request as HttpRequest};
+use http_client::{AsyncBody, HttpClient, Method, Request as HttpRequest};
 use serde::{Deserialize, Serialize};
 use strum::{EnumIter, EnumString};
 use thiserror::Error;
@@ -207,9 +206,8 @@ pub async fn stream_completion(
    api_url: &str,
    api_key: &str,
    request: Request,
-    low_speed_timeout: Option<Duration>,
 ) -> Result<BoxStream<'static, Result<Event, AnthropicError>>, AnthropicError> {
-    stream_completion_with_rate_limit_info(client, api_url, api_key, request, low_speed_timeout)
+    stream_completion_with_rate_limit_info(client, api_url, api_key, request)
        .await
        .map(|output| output.0)
 }
@@ -261,7 +259,6 @@ pub async fn stream_completion_with_rate_limit_info(
    api_url: &str,
    api_key: &str,
    request: Request,
-    low_speed_timeout: Option<Duration>,
 ) -> Result<
    (
        BoxStream<'static, Result<Event, AnthropicError>>,
@@ -274,7 +271,7 @@ pub async fn stream_completion_with_rate_limit_info(
        stream: true,
    };
    let uri = format!("{api_url}/v1/messages");
-    let mut request_builder = HttpRequest::builder()
+    let request_builder = HttpRequest::builder()
        .method(Method::POST)
        .uri(uri)
        .header("Anthropic-Version", "2023-06-01")
@@ -284,9 +281,6 @@ pub async fn stream_completion_with_rate_limit_info(
        )
        .header("X-Api-Key", api_key)
        .header("Content-Type", "application/json");
-    if let Some(low_speed_timeout) = low_speed_timeout {
-        request_builder = request_builder.read_timeout(low_speed_timeout);
-    }
    let serialized_request =
        serde_json::to_string(&request).context("failed to serialize request")?;
    let request = request_builder
--- a/crates/assistant/Cargo.toml
+++ b/crates/assistant/Cargo.toml
@@ -50,6 +50,7 @@ indexed_docs.workspace = true
 indoc.workspace = true
 language.workspace = true
 language_model.workspace = true
+language_models.workspace = true
 log.workspace = true
 lsp.workspace = true
 markdown.workspace = true
--- a/crates/assistant/src/assistant.rs
+++ b/crates/assistant/src/assistant.rs
@@ -18,6 +18,7 @@ mod terminal_inline_assistant;
 mod tool_working_set;
 mod tools;

+use crate::slash_command::project_command::ProjectSlashCommandFeatureFlag;
 pub use crate::slash_command_working_set::{SlashCommandId, SlashCommandWorkingSet};
 pub use crate::tool_working_set::{ToolId, ToolWorkingSet};
 pub use assistant_panel::{AssistantPanel, AssistantPanelEvent};
@@ -32,7 +33,6 @@ use feature_flags::FeatureFlagAppExt;
 use fs::Fs;
 use gpui::impl_actions;
 use gpui::{actions, AppContext, Global, SharedString, UpdateGlobal};
-use indexed_docs::IndexedDocsRegistry;
 pub(crate) use inline_assistant::*;
 use language_model::{
    LanguageModelId, LanguageModelProviderId, LanguageModelRegistry, LanguageModelResponseMessage,
@@ -215,23 +215,32 @@ pub fn init(
        });
    }

-    if cx.has_flag::<SearchSlashCommandFeatureFlag>() {
-        cx.spawn(|mut cx| {
-            let client = client.clone();
-            async move {
-                let embedding_provider = CloudEmbeddingProvider::new(client.clone());
-                let semantic_index = SemanticDb::new(
-                    paths::embeddings_dir().join("semantic-index-db.0.mdb"),
-                    Arc::new(embedding_provider),
-                    &mut cx,
-                )
-                .await?;
+    cx.spawn(|mut cx| {
+        let client = client.clone();
+        async move {
+            let is_search_slash_command_enabled = cx
+                .update(|cx| cx.wait_for_flag::<SearchSlashCommandFeatureFlag>())?
+                .await;
+            let is_project_slash_command_enabled = cx
+                .update(|cx| cx.wait_for_flag::<ProjectSlashCommandFeatureFlag>())?
+                .await;

-                cx.update(|cx| cx.set_global(semantic_index))
+            if !is_search_slash_command_enabled && !is_project_slash_command_enabled {
+                return Ok(());
            }
-        })
-        .detach();
-    }
+
+            let embedding_provider = CloudEmbeddingProvider::new(client.clone());
+            let semantic_index = SemanticDb::new(
+                paths::embeddings_dir().join("semantic-index-db.0.mdb"),
+                Arc::new(embedding_provider),
+                &mut cx,
+            )
+            .await?;
+
+            cx.update(|cx| cx.set_global(semantic_index))
+        }
+    })
+    .detach();

    context_store::init(&client.clone().into());
    prompt_library::init(cx);
@@ -265,7 +274,7 @@ pub fn init(
        client.telemetry().clone(),
        cx,
    );
-    IndexedDocsRegistry::init_global(cx);
+    indexed_docs::init(cx);

    CommandPaletteFilter::update_global(cx, |filter, _cx| {
        filter.hide_namespace(Assistant::NAMESPACE);
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -50,11 +50,11 @@ use indexed_docs::IndexedDocsStore;
 use language::{
    language_settings::SoftWrap, BufferSnapshot, LanguageRegistry, LspAdapterDelegate, ToOffset,
 };
-use language_model::{
-    provider::cloud::PROVIDER_ID, LanguageModelProvider, LanguageModelProviderId,
-    LanguageModelRegistry, Role,
-};
 use language_model::{LanguageModelImage, LanguageModelToolUse};
+use language_model::{
+    LanguageModelProvider, LanguageModelProviderId, LanguageModelRegistry, Role,
+    ZED_CLOUD_PROVIDER_ID,
+};
 use multi_buffer::MultiBufferRow;
 use picker::{Picker, PickerDelegate};
 use project::lsp_store::LocalLspAdapterDelegate;
@@ -664,7 +664,7 @@ impl AssistantPanel {
        // If we're signed out and don't have a provider configured, or we're signed-out AND Zed.dev is
        // the provider, we want to show a nudge to sign in.
        let show_zed_ai_notice = client_status.is_signed_out()
-            && active_provider.map_or(true, |provider| provider.id().0 == PROVIDER_ID);
+            && active_provider.map_or(true, |provider| provider.id().0 == ZED_CLOUD_PROVIDER_ID);

        self.show_zed_ai_notice = show_zed_ai_notice;
        cx.notify();
@@ -2050,30 +2050,6 @@ impl ContextEditor {
            ContextEvent::SlashCommandOutputSectionAdded { section } => {
                self.insert_slash_command_output_sections([section.clone()], false, cx);
            }
-            ContextEvent::SlashCommandFinished {
-                output_range: _output_range,
-                run_commands_in_ranges,
-            } => {
-                for range in run_commands_in_ranges {
-                    let commands = self.context.update(cx, |context, cx| {
-                        context.reparse(cx);
-                        context
-                            .pending_commands_for_range(range.clone(), cx)
-                            .to_vec()
-                    });
-
-                    for command in commands {
-                        self.run_command(
-                            command.source_range,
-                            &command.name,
-                            &command.arguments,
-                            false,
-                            self.workspace.clone(),
-                            cx,
-                        );
-                    }
-                }
-            }
            ContextEvent::UsePendingTools => {
                let pending_tool_uses = self
                    .context
@@ -2152,6 +2128,37 @@ impl ContextEditor {
        command_id: InvokedSlashCommandId,
        cx: &mut ViewContext<Self>,
    ) {
+        if let Some(invoked_slash_command) =
+            self.context.read(cx).invoked_slash_command(&command_id)
+        {
+            if let InvokedSlashCommandStatus::Finished = invoked_slash_command.status {
+                let run_commands_in_ranges = invoked_slash_command
+                    .run_commands_in_ranges
+                    .iter()
+                    .cloned()
+                    .collect::<Vec<_>>();
+                for range in run_commands_in_ranges {
+                    let commands = self.context.update(cx, |context, cx| {
+                        context.reparse(cx);
+                        context
+                            .pending_commands_for_range(range.clone(), cx)
+                            .to_vec()
+                    });
+
+                    for command in commands {
+                        self.run_command(
+                            command.source_range,
+                            &command.name,
+                            &command.arguments,
+                            false,
+                            self.workspace.clone(),
+                            cx,
+                        );
+                    }
+                }
+            }
+        }
+
        self.editor.update(cx, |editor, cx| {
            if let Some(invoked_slash_command) =
                self.context.read(cx).invoked_slash_command(&command_id)
@@ -3333,7 +3340,8 @@ impl ContextEditor {

            self.context.update(cx, |context, cx| {
                for image in images {
-                    let Some(render_image) = image.to_image_data(cx).log_err() else {
+                    let Some(render_image) = image.to_image_data(cx.svg_renderer()).log_err()
+                    else {
                        continue;
                    };
                    let image_id = image.id();
@@ -3920,7 +3928,7 @@ impl ContextEditor {
            .child(
                div()
                    .id("error-message")
-                    .max_h_24()
+                    .max_h_32()
                    .overflow_y_scroll()
                    .child(Label::new(error_message.clone())),
            )
--- a/crates/assistant/src/assistant_settings.rs
+++ b/crates/assistant/src/assistant_settings.rs
@@ -5,13 +5,12 @@ use anthropic::Model as AnthropicModel;
 use feature_flags::FeatureFlagAppExt;
 use fs::Fs;
 use gpui::{AppContext, Pixels};
-use language_model::provider::open_ai;
-use language_model::settings::{
-    AnthropicSettingsContent, AnthropicSettingsContentV1, OllamaSettingsContent,
-    OpenAiSettingsContent, OpenAiSettingsContentV1, VersionedAnthropicSettingsContent,
-    VersionedOpenAiSettingsContent,
+use language_model::{CloudModel, LanguageModel};
+use language_models::{
+    provider::open_ai, AllLanguageModelSettings, AnthropicSettingsContent,
+    AnthropicSettingsContentV1, OllamaSettingsContent, OpenAiSettingsContent,
+    OpenAiSettingsContentV1, VersionedAnthropicSettingsContent, VersionedOpenAiSettingsContent,
 };
-use language_model::{settings::AllLanguageModelSettings, CloudModel, LanguageModel};
 use ollama::Model as OllamaModel;
 use schemars::{schema::Schema, JsonSchema};
 use serde::{Deserialize, Serialize};
@@ -35,20 +34,17 @@ pub enum AssistantProviderContentV1 {
    OpenAi {
        default_model: Option<OpenAiModel>,
        api_url: Option<String>,
-        low_speed_timeout_in_seconds: Option<u64>,
        available_models: Option<Vec<OpenAiModel>>,
    },
    #[serde(rename = "anthropic")]
    Anthropic {
        default_model: Option<AnthropicModel>,
        api_url: Option<String>,
-        low_speed_timeout_in_seconds: Option<u64>,
    },
    #[serde(rename = "ollama")]
    Ollama {
        default_model: Option<OllamaModel>,
        api_url: Option<String>,
-        low_speed_timeout_in_seconds: Option<u64>,
    },
 }

@@ -63,6 +59,7 @@ pub struct AssistantSettings {
    pub inline_alternatives: Vec<LanguageModelSelection>,
    pub using_outdated_settings_version: bool,
    pub enable_experimental_live_diffs: bool,
+    pub show_hints: bool,
 }

 impl AssistantSettings {
@@ -115,47 +112,41 @@ impl AssistantSettingsContent {
            if let VersionedAssistantSettingsContent::V1(settings) = settings {
                if let Some(provider) = settings.provider.clone() {
                    match provider {
-                        AssistantProviderContentV1::Anthropic {
-                            api_url,
-                            low_speed_timeout_in_seconds,
-                            ..
-                        } => update_settings_file::<AllLanguageModelSettings>(
-                            fs,
-                            cx,
-                            move |content, _| {
-                                if content.anthropic.is_none() {
-                                    content.anthropic = Some(AnthropicSettingsContent::Versioned(
-                                        VersionedAnthropicSettingsContent::V1(
-                                            AnthropicSettingsContentV1 {
-                                                api_url,
-                                                low_speed_timeout_in_seconds,
-                                                available_models: None,
-                                            },
-                                        ),
-                                    ));
-                                }
-                            },
-                        ),
-                        AssistantProviderContentV1::Ollama {
-                            api_url,
-                            low_speed_timeout_in_seconds,
-                            ..
-                        } => update_settings_file::<AllLanguageModelSettings>(
-                            fs,
-                            cx,
-                            move |content, _| {
-                                if content.ollama.is_none() {
-                                    content.ollama = Some(OllamaSettingsContent {
-                                        api_url,
-                                        low_speed_timeout_in_seconds,
-                                        available_models: None,
-                                    });
-                                }
-                            },
-                        ),
+                        AssistantProviderContentV1::Anthropic { api_url, .. } => {
+                            update_settings_file::<AllLanguageModelSettings>(
+                                fs,
+                                cx,
+                                move |content, _| {
+                                    if content.anthropic.is_none() {
+                                        content.anthropic =
+                                            Some(AnthropicSettingsContent::Versioned(
+                                                VersionedAnthropicSettingsContent::V1(
+                                                    AnthropicSettingsContentV1 {
+                                                        api_url,
+                                                        available_models: None,
+                                                    },
+                                                ),
+                                            ));
+                                    }
+                                },
+                            )
+                        }
+                        AssistantProviderContentV1::Ollama { api_url, .. } => {
+                            update_settings_file::<AllLanguageModelSettings>(
+                                fs,
+                                cx,
+                                move |content, _| {
+                                    if content.ollama.is_none() {
+                                        content.ollama = Some(OllamaSettingsContent {
+                                            api_url,
+                                            available_models: None,
+                                        });
+                                    }
+                                },
+                            )
+                        }
                        AssistantProviderContentV1::OpenAi {
                            api_url,
-                            low_speed_timeout_in_seconds,
                            available_models,
                            ..
                        } => update_settings_file::<AllLanguageModelSettings>(
@@ -188,7 +179,6 @@ impl AssistantSettingsContent {
                                        VersionedOpenAiSettingsContent::V1(
                                            OpenAiSettingsContentV1 {
                                                api_url,
-                                                low_speed_timeout_in_seconds,
                                                available_models,
                                            },
                                        ),
@@ -212,6 +202,7 @@ impl AssistantSettingsContent {
            AssistantSettingsContent::Versioned(settings) => match settings {
                VersionedAssistantSettingsContent::V1(settings) => AssistantSettingsContentV2 {
                    enabled: settings.enabled,
+                    show_hints: None,
                    button: settings.button,
                    dock: settings.dock,
                    default_width: settings.default_width,
@@ -252,6 +243,7 @@ impl AssistantSettingsContent {
            },
            AssistantSettingsContent::Legacy(settings) => AssistantSettingsContentV2 {
                enabled: None,
+                show_hints: None,
                button: settings.button,
                dock: settings.dock,
                default_width: settings.default_width,
@@ -298,54 +290,41 @@ impl AssistantSettingsContent {
                        log::warn!("attempted to set zed.dev model on outdated settings");
                    }
                    "anthropic" => {
-                        let (api_url, low_speed_timeout_in_seconds) = match &settings.provider {
-                            Some(AssistantProviderContentV1::Anthropic {
-                                api_url,
-                                low_speed_timeout_in_seconds,
-                                ..
-                            }) => (api_url.clone(), *low_speed_timeout_in_seconds),
-                            _ => (None, None),
+                        let api_url = match &settings.provider {
+                            Some(AssistantProviderContentV1::Anthropic { api_url, .. }) => {
+                                api_url.clone()
+                            }
+                            _ => None,
                        };
                        settings.provider = Some(AssistantProviderContentV1::Anthropic {
                            default_model: AnthropicModel::from_id(&model).ok(),
                            api_url,
-                            low_speed_timeout_in_seconds,
                        });
                    }
                    "ollama" => {
-                        let (api_url, low_speed_timeout_in_seconds) = match &settings.provider {
-                            Some(AssistantProviderContentV1::Ollama {
-                                api_url,
-                                low_speed_timeout_in_seconds,
-                                ..
-                            }) => (api_url.clone(), *low_speed_timeout_in_seconds),
-                            _ => (None, None),
+                        let api_url = match &settings.provider {
+                            Some(AssistantProviderContentV1::Ollama { api_url, .. }) => {
+                                api_url.clone()
+                            }
+                            _ => None,
                        };
                        settings.provider = Some(AssistantProviderContentV1::Ollama {
                            default_model: Some(ollama::Model::new(&model, None, None)),
                            api_url,
-                            low_speed_timeout_in_seconds,
                        });
                    }
                    "openai" => {
-                        let (api_url, low_speed_timeout_in_seconds, available_models) =
-                            match &settings.provider {
-                                Some(AssistantProviderContentV1::OpenAi {
-                                    api_url,
-                                    low_speed_timeout_in_seconds,
-                                    available_models,
-                                    ..
-                                }) => (
-                                    api_url.clone(),
-                                    *low_speed_timeout_in_seconds,
-                                    available_models.clone(),
-                                ),
-                                _ => (None, None, None),
-                            };
+                        let (api_url, available_models) = match &settings.provider {
+                            Some(AssistantProviderContentV1::OpenAi {
+                                api_url,
+                                available_models,
+                                ..
+                            }) => (api_url.clone(), available_models.clone()),
+                            _ => (None, None),
+                        };
                        settings.provider = Some(AssistantProviderContentV1::OpenAi {
                            default_model: OpenAiModel::from_id(&model).ok(),
                            api_url,
-                            low_speed_timeout_in_seconds,
                            available_models,
                        });
                    }
@@ -377,6 +356,7 @@ impl Default for VersionedAssistantSettingsContent {
    fn default() -> Self {
        Self::V2(AssistantSettingsContentV2 {
            enabled: None,
+            show_hints: None,
            button: None,
            dock: None,
            default_width: None,
@@ -394,6 +374,11 @@ pub struct AssistantSettingsContentV2 {
    ///
    /// Default: true
    enabled: Option<bool>,
+    /// Whether to show inline hints that show keybindings for inline assistant
+    /// and assistant panel.
+    ///
+    /// Default: true
+    show_hints: Option<bool>,
    /// Whether to show the assistant panel button in the status bar.
    ///
    /// Default: true
@@ -528,6 +513,7 @@ impl Settings for AssistantSettings {

            let value = value.upgrade();
            merge(&mut settings.enabled, value.enabled);
+            merge(&mut settings.show_hints, value.show_hints);
            merge(&mut settings.button, value.button);
            merge(&mut settings.dock, value.dock);
            merge(
@@ -598,6 +584,7 @@ mod tests {
                            }),
                            inline_alternatives: None,
                            enabled: None,
+                            show_hints: None,
                            button: None,
                            dock: None,
                            default_width: None,
--- a/crates/assistant/src/context.rs
+++ b/crates/assistant/src/context.rs
@@ -25,13 +25,15 @@ use gpui::{

 use language::{AnchorRangeExt, Bias, Buffer, LanguageRegistry, OffsetRangeExt, Point, ToOffset};
 use language_model::{
-    logging::report_assistant_event,
-    provider::cloud::{MaxMonthlySpendReachedError, PaymentRequiredError},
    LanguageModel, LanguageModelCacheConfiguration, LanguageModelCompletionEvent,
    LanguageModelImage, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
    LanguageModelRequestTool, LanguageModelToolResult, LanguageModelToolUse, MessageContent, Role,
    StopReason,
 };
+use language_models::{
+    provider::cloud::{MaxMonthlySpendReachedError, PaymentRequiredError},
+    report_assistant_event,
+};
 use open_ai::Model as OpenAiModel;
 use paths::contexts_dir;
 use project::Project;
@@ -381,10 +383,6 @@ pub enum ContextEvent {
    SlashCommandOutputSectionAdded {
        section: SlashCommandOutputSection<language::Anchor>,
    },
-    SlashCommandFinished {
-        output_range: Range<language::Anchor>,
-        run_commands_in_ranges: Vec<Range<language::Anchor>>,
-    },
    UsePendingTools,
    ToolFinished {
        tool_use_id: Arc<str>,
@@ -916,6 +914,7 @@ impl Context {
                        InvokedSlashCommand {
                            name: name.into(),
                            range: output_range,
+                            run_commands_in_ranges: Vec::new(),
                            status: InvokedSlashCommandStatus::Running(Task::ready(())),
                            transaction: None,
                            timestamp: id.0,
@@ -1914,7 +1913,6 @@ impl Context {
                }

                let mut pending_section_stack: Vec<PendingSection> = Vec::new();
-                let mut run_commands_in_ranges: Vec<Range<language::Anchor>> = Vec::new();
                let mut last_role: Option<Role> = None;
                let mut last_section_range = None;

@@ -1980,7 +1978,13 @@ impl Context {

                                let end = this.buffer.read(cx).anchor_before(insert_position);
                                if run_commands_in_text {
-                                    run_commands_in_ranges.push(start..end);
+                                    if let Some(invoked_slash_command) =
+                                        this.invoked_slash_commands.get_mut(&command_id)
+                                    {
+                                        invoked_slash_command
+                                            .run_commands_in_ranges
+                                            .push(start..end);
+                                    }
                                }
                            }
                            SlashCommandEvent::EndSection => {
@@ -2100,6 +2104,7 @@ impl Context {
            InvokedSlashCommand {
                name: name.to_string().into(),
                range: command_range.clone(),
+                run_commands_in_ranges: Vec::new(),
                status: InvokedSlashCommandStatus::Running(insert_output_task),
                transaction: Some(first_transaction),
                timestamp: command_id.0,
@@ -2383,7 +2388,11 @@ impl Context {
                            });
                            Some(error.to_string())
                        } else {
-                            let error_message = error.to_string().trim().to_string();
+                            let error_message = error
+                                .chain()
+                                .map(|err| err.to_string())
+                                .collect::<Vec<_>>()
+                                .join("\n");
                            cx.emit(ContextEvent::ShowAssistError(SharedString::from(
                                error_message.clone(),
                            )));
@@ -2887,7 +2896,7 @@ impl Context {
            request.messages.push(LanguageModelRequestMessage {
                role: Role::User,
                content: vec![
-                    "Generate a concise 3-7 word title for this conversation, omitting punctuation"
+                    "Generate a concise 3-7 word title for this conversation, omitting punctuation. Go straight to the title, without any preamble and prefix like `Here's a concise suggestion:...` or `Title:`"
                        .into(),
                ],
                cache: false,
@@ -3172,6 +3181,7 @@ pub struct ParsedSlashCommand {
 pub struct InvokedSlashCommand {
    pub name: SharedString,
    pub range: Range<language::Anchor>,
+    pub run_commands_in_ranges: Vec<Range<language::Anchor>>,
    pub status: InvokedSlashCommandStatus,
    pub transaction: Option<language::TransactionId>,
    timestamp: clock::Lamport,
--- a/crates/assistant/src/context_store.rs
+++ b/crates/assistant/src/context_store.rs
@@ -770,7 +770,7 @@ impl ContextStore {
                        contexts.push(SavedContextMetadata {
                            title: title.to_string(),
                            path,
-                            mtime: metadata.mtime.into(),
+                            mtime: metadata.mtime.timestamp_for_user().into(),
                        });
                    }
                }
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -30,9 +30,10 @@ use gpui::{
 };
 use language::{Buffer, IndentKind, Point, Selection, TransactionId};
 use language_model::{
-    logging::report_assistant_event, LanguageModel, LanguageModelRegistry, LanguageModelRequest,
-    LanguageModelRequestMessage, LanguageModelTextStream, Role,
+    LanguageModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
+    LanguageModelTextStream, Role,
 };
+use language_models::report_assistant_event;
 use multi_buffer::MultiBufferRow;
 use parking_lot::Mutex;
 use project::{CodeAction, ProjectTransaction};
--- a/crates/assistant/src/slash_command/context_server_command.rs
+++ b/crates/assistant/src/slash_command/context_server_command.rs
@@ -152,7 +152,7 @@ impl SlashCommand for ContextServerSlashCommand {
                if result
                    .messages
                    .iter()
-                    .any(|msg| !matches!(msg.role, context_servers::types::SamplingRole::User))
+                    .any(|msg| !matches!(msg.role, context_servers::types::Role::User))
                {
                    return Err(anyhow!(
                        "Prompt contains non-user roles, which is not supported"
@@ -164,7 +164,7 @@ impl SlashCommand for ContextServerSlashCommand {
                    .messages
                    .into_iter()
                    .filter_map(|msg| match msg.content {
-                        context_servers::types::SamplingContent::Text { text } => Some(text),
+                        context_servers::types::MessageContent::Text { text } => Some(text),
                        _ => None,
                    })
                    .collect::<Vec<String>>()
--- a/crates/assistant/src/slash_command/default_command.rs
+++ b/crates/assistant/src/slash_command/default_command.rs
@@ -69,6 +69,10 @@ impl SlashCommand for DefaultSlashCommand {
                text.push('\n');
            }

+            if !text.ends_with('\n') {
+                text.push('\n');
+            }
+
            Ok(SlashCommandOutput {
                sections: vec![SlashCommandOutputSection {
                    range: 0..text.len(),
--- a/crates/assistant/src/terminal_inline_assistant.rs
+++ b/crates/assistant/src/terminal_inline_assistant.rs
@@ -17,9 +17,9 @@ use gpui::{
 };
 use language::Buffer;
 use language_model::{
-    logging::report_assistant_event, LanguageModelRegistry, LanguageModelRequest,
-    LanguageModelRequestMessage, Role,
+    LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role,
 };
+use language_models::report_assistant_event;
 use settings::Settings;
 use std::{
    cmp,
--- a/crates/assistant/src/tools/context_server_tool.rs
+++ b/crates/assistant/src/tools/context_server_tool.rs
@@ -74,11 +74,21 @@ impl Tool for ContextServerTool {
                    );
                    let response = protocol.run_tool(tool_name, arguments).await?;

-                    let tool_result = match response.tool_result {
-                        serde_json::Value::String(s) => s,
-                        _ => serde_json::to_string(&response.tool_result)?,
-                    };
-                    Ok(tool_result)
+                    let mut result = String::new();
+                    for content in response.content {
+                        match content {
+                            types::ToolResponseContent::Text { text } => {
+                                result.push_str(&text);
+                            }
+                            types::ToolResponseContent::Image { .. } => {
+                                log::warn!("Ignoring image content from tool response");
+                            }
+                            types::ToolResponseContent::Resource { .. } => {
+                                log::warn!("Ignoring resource content from tool response");
+                            }
+                        }
+                    }
+                    Ok(result)
                }
            })
        } else {
--- a/crates/assistant_slash_command/src/assistant_slash_command.rs
+++ b/crates/assistant_slash_command/src/assistant_slash_command.rs
@@ -18,6 +18,7 @@ use workspace::{ui::IconName, Workspace};

 pub fn init(cx: &mut AppContext) {
    SlashCommandRegistry::default_global(cx);
+    extension_slash_command::init(cx);
 }

 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
--- a/crates/assistant_slash_command/src/extension_slash_command.rs
+++ b/crates/assistant_slash_command/src/extension_slash_command.rs
@@ -3,17 +3,39 @@ use std::sync::{atomic::AtomicBool, Arc};

 use anyhow::Result;
 use async_trait::async_trait;
-use extension::{Extension, WorktreeDelegate};
-use gpui::{Task, WeakView, WindowContext};
+use extension::{Extension, ExtensionHostProxy, ExtensionSlashCommandProxy, WorktreeDelegate};
+use gpui::{AppContext, Task, WeakView, WindowContext};
 use language::{BufferSnapshot, LspAdapterDelegate};
 use ui::prelude::*;
 use workspace::Workspace;

 use crate::{
    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-    SlashCommandResult,
+    SlashCommandRegistry, SlashCommandResult,
 };

+pub fn init(cx: &mut AppContext) {
+    let proxy = ExtensionHostProxy::default_global(cx);
+    proxy.register_slash_command_proxy(SlashCommandRegistryProxy {
+        slash_command_registry: SlashCommandRegistry::global(cx),
+    });
+}
+
+struct SlashCommandRegistryProxy {
+    slash_command_registry: Arc<SlashCommandRegistry>,
+}
+
+impl ExtensionSlashCommandProxy for SlashCommandRegistryProxy {
+    fn register_slash_command(
+        &self,
+        extension: Arc<dyn Extension>,
+        command: extension::SlashCommand,
+    ) {
+        self.slash_command_registry
+            .register_command(ExtensionSlashCommand::new(extension, command), false)
+    }
+}
+
 /// An adapter that allows an [`LspAdapterDelegate`] to be used as a [`WorktreeDelegate`].
 struct WorktreeDelegateAdapter(Arc<dyn LspAdapterDelegate>);

--- a/crates/auto_update/Cargo.toml
+++ b/crates/auto_update/Cargo.toml
@@ -16,21 +16,16 @@ doctest = false
 anyhow.workspace = true
 client.workspace = true
 db.workspace = true
-editor.workspace = true
 gpui.workspace = true
 http_client.workspace = true
 log.workspace = true
-markdown_preview.workspace = true
-menu.workspace = true
 paths.workspace = true
 release_channel.workspace = true
 schemars.workspace = true
 serde.workspace = true
-serde_derive.workspace = true
 serde_json.workspace = true
 settings.workspace = true
 smol.workspace = true
 tempfile.workspace = true
-util.workspace = true
 which.workspace = true
 workspace.workspace = true
--- a/crates/auto_update/src/auto_update.rs
+++ b/crates/auto_update/src/auto_update.rs
@@ -1,27 +1,19 @@
-mod update_notification;
-
 use anyhow::{anyhow, Context, Result};
 use client::{Client, TelemetrySettings};
 use db::kvp::KEY_VALUE_STORE;
 use db::RELEASE_CHANNEL;
-use editor::{Editor, MultiBuffer};
 use gpui::{
    actions, AppContext, AsyncAppContext, Context as _, Global, Model, ModelContext,
-    SemanticVersion, SharedString, Task, View, ViewContext, VisualContext, WindowContext,
+    SemanticVersion, Task, WindowContext,
 };
-
-use markdown_preview::markdown_preview_view::{MarkdownPreviewMode, MarkdownPreviewView};
-use paths::remote_servers_dir;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde_derive::Serialize;
-use smol::{fs, io::AsyncReadExt};
-
-use settings::{Settings, SettingsSources, SettingsStore};
-use smol::{fs::File, process::Command};
-
 use http_client::{AsyncBody, HttpClient, HttpClientWithUrl};
-use release_channel::{AppCommitSha, AppVersion, ReleaseChannel};
+use paths::remote_servers_dir;
+use release_channel::{AppCommitSha, ReleaseChannel};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use settings::{Settings, SettingsSources, SettingsStore};
+use smol::{fs, io::AsyncReadExt};
+use smol::{fs::File, process::Command};
 use std::{
    env::{
        self,
@@ -32,24 +24,13 @@ use std::{
    sync::Arc,
    time::Duration,
 };
-use update_notification::UpdateNotification;
-use util::ResultExt;
 use which::which;
-use workspace::notifications::NotificationId;
 use workspace::Workspace;

 const SHOULD_SHOW_UPDATE_NOTIFICATION_KEY: &str = "auto-updater-should-show-updated-notification";
 const POLL_INTERVAL: Duration = Duration::from_secs(60 * 60);

-actions!(
-    auto_update,
-    [
-        Check,
-        DismissErrorMessage,
-        ViewReleaseNotes,
-        ViewReleaseNotesLocally
-    ]
-);
+actions!(auto_update, [Check, DismissErrorMessage, ViewReleaseNotes,]);

 #[derive(Serialize)]
 struct UpdateRequestBody {
@@ -146,12 +127,6 @@ struct GlobalAutoUpdate(Option<Model<AutoUpdater>>);

 impl Global for GlobalAutoUpdate {}

-#[derive(Deserialize)]
-struct ReleaseNotesBody {
-    title: String,
-    release_notes: String,
-}
-
 pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut AppContext) {
    AutoUpdateSetting::register(cx);

@@ -161,10 +136,6 @@ pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut AppContext) {
        workspace.register_action(|_, action, cx| {
            view_release_notes(action, cx);
        });
-
-        workspace.register_action(|workspace, _: &ViewReleaseNotesLocally, cx| {
-            view_release_notes_locally(workspace, cx);
-        });
    })
    .detach();

@@ -264,121 +235,6 @@ pub fn view_release_notes(_: &ViewReleaseNotes, cx: &mut AppContext) -> Option<(
    None
 }

-fn view_release_notes_locally(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) {
-    let release_channel = ReleaseChannel::global(cx);
-
-    let url = match release_channel {
-        ReleaseChannel::Nightly => Some("https://github.com/zed-industries/zed/commits/nightly/"),
-        ReleaseChannel::Dev => Some("https://github.com/zed-industries/zed/commits/main/"),
-        _ => None,
-    };
-
-    if let Some(url) = url {
-        cx.open_url(url);
-        return;
-    }
-
-    let version = AppVersion::global(cx).to_string();
-
-    let client = client::Client::global(cx).http_client();
-    let url = client.build_url(&format!(
-        "/api/release_notes/v2/{}/{}",
-        release_channel.dev_name(),
-        version
-    ));
-
-    let markdown = workspace
-        .app_state()
-        .languages
-        .language_for_name("Markdown");
-
-    workspace
-        .with_local_workspace(cx, move |_, cx| {
-            cx.spawn(|workspace, mut cx| async move {
-                let markdown = markdown.await.log_err();
-                let response = client.get(&url, Default::default(), true).await;
-                let Some(mut response) = response.log_err() else {
-                    return;
-                };
-
-                let mut body = Vec::new();
-                response.body_mut().read_to_end(&mut body).await.ok();
-
-                let body: serde_json::Result<ReleaseNotesBody> =
-                    serde_json::from_slice(body.as_slice());
-
-                if let Ok(body) = body {
-                    workspace
-                        .update(&mut cx, |workspace, cx| {
-                            let project = workspace.project().clone();
-                            let buffer = project.update(cx, |project, cx| {
-                                project.create_local_buffer("", markdown, cx)
-                            });
-                            buffer.update(cx, |buffer, cx| {
-                                buffer.edit([(0..0, body.release_notes)], None, cx)
-                            });
-                            let language_registry = project.read(cx).languages().clone();
-
-                            let buffer = cx.new_model(|cx| MultiBuffer::singleton(buffer, cx));
-
-                            let tab_description = SharedString::from(body.title.to_string());
-                            let editor = cx.new_view(|cx| {
-                                Editor::for_multibuffer(buffer, Some(project), true, cx)
-                            });
-                            let workspace_handle = workspace.weak_handle();
-                            let view: View<MarkdownPreviewView> = MarkdownPreviewView::new(
-                                MarkdownPreviewMode::Default,
-                                editor,
-                                workspace_handle,
-                                language_registry,
-                                Some(tab_description),
-                                cx,
-                            );
-                            workspace.add_item_to_active_pane(
-                                Box::new(view.clone()),
-                                None,
-                                true,
-                                cx,
-                            );
-                            cx.notify();
-                        })
-                        .log_err();
-                }
-            })
-            .detach();
-        })
-        .detach();
-}
-
-pub fn notify_of_any_new_update(cx: &mut ViewContext<Workspace>) -> Option<()> {
-    let updater = AutoUpdater::get(cx)?;
-    let version = updater.read(cx).current_version;
-    let should_show_notification = updater.read(cx).should_show_update_notification(cx);
-
-    cx.spawn(|workspace, mut cx| async move {
-        let should_show_notification = should_show_notification.await?;
-        if should_show_notification {
-            workspace.update(&mut cx, |workspace, cx| {
-                let workspace_handle = workspace.weak_handle();
-                workspace.show_notification(
-                    NotificationId::unique::<UpdateNotification>(),
-                    cx,
-                    |cx| cx.new_view(|_| UpdateNotification::new(version, workspace_handle)),
-                );
-                updater.update(cx, |updater, cx| {
-                    updater
-                        .set_should_show_update_notification(false, cx)
-                        .detach_and_log_err(cx);
-                });
-            })?;
-        }
-        anyhow::Ok(())
-    })
-    .detach();
-
-    None
-}
-
 impl AutoUpdater {
    pub fn get(cx: &mut AppContext) -> Option<Model<Self>> {
        cx.default_global::<GlobalAutoUpdate>().0.clone()
@@ -423,6 +279,10 @@ impl AutoUpdater {
        }));
    }

+    pub fn current_version(&self) -> SemanticVersion {
+        self.current_version
+    }
+
    pub fn status(&self) -> AutoUpdateStatus {
        self.status.clone()
    }
@@ -646,7 +506,7 @@ impl AutoUpdater {
        Ok(())
    }

-    fn set_should_show_update_notification(
+    pub fn set_should_show_update_notification(
        &self,
        should_show: bool,
        cx: &AppContext,
@@ -668,7 +528,7 @@ impl AutoUpdater {
        })
    }

-    fn should_show_update_notification(&self, cx: &AppContext) -> Task<Result<bool>> {
+    pub fn should_show_update_notification(&self, cx: &AppContext) -> Task<Result<bool>> {
        cx.background_executor().spawn(async move {
            Ok(KEY_VALUE_STORE
                .read_kvp(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY)?
--- a/crates/auto_update_ui/Cargo.toml
+++ b/crates/auto_update_ui/Cargo.toml
@@ -0,0 +1,28 @@
+[package]
+name = "auto_update_ui"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/auto_update_ui.rs"
+
+[dependencies]
+anyhow.workspace = true
+auto_update.workspace = true
+client.workspace = true
+editor.workspace = true
+gpui.workspace = true
+http_client.workspace = true
+markdown_preview.workspace = true
+menu.workspace = true
+release_channel.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+smol.workspace = true
+util.workspace = true
+workspace.workspace = true
--- a/crates/quick_action_bar/LICENSE-GPL
+++ b/crates/quick_action_bar/LICENSE-GPL
--- a/crates/auto_update_ui/src/auto_update_ui.rs
+++ b/crates/auto_update_ui/src/auto_update_ui.rs
@@ -0,0 +1,147 @@
+mod update_notification;
+
+use auto_update::AutoUpdater;
+use editor::{Editor, MultiBuffer};
+use gpui::{actions, prelude::*, AppContext, SharedString, View, ViewContext};
+use http_client::HttpClient;
+use markdown_preview::markdown_preview_view::{MarkdownPreviewMode, MarkdownPreviewView};
+use release_channel::{AppVersion, ReleaseChannel};
+use serde::Deserialize;
+use smol::io::AsyncReadExt;
+use util::ResultExt as _;
+use workspace::notifications::NotificationId;
+use workspace::Workspace;
+
+use crate::update_notification::UpdateNotification;
+
+actions!(auto_update, [ViewReleaseNotesLocally]);
+
+pub fn init(cx: &mut AppContext) {
+    cx.observe_new_views(|workspace: &mut Workspace, _cx| {
+        workspace.register_action(|workspace, _: &ViewReleaseNotesLocally, cx| {
+            view_release_notes_locally(workspace, cx);
+        });
+    })
+    .detach();
+}
+
+#[derive(Deserialize)]
+struct ReleaseNotesBody {
+    title: String,
+    release_notes: String,
+}
+
+fn view_release_notes_locally(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) {
+    let release_channel = ReleaseChannel::global(cx);
+
+    let url = match release_channel {
+        ReleaseChannel::Nightly => Some("https://github.com/zed-industries/zed/commits/nightly/"),
+        ReleaseChannel::Dev => Some("https://github.com/zed-industries/zed/commits/main/"),
+        _ => None,
+    };
+
+    if let Some(url) = url {
+        cx.open_url(url);
+        return;
+    }
+
+    let version = AppVersion::global(cx).to_string();
+
+    let client = client::Client::global(cx).http_client();
+    let url = client.build_url(&format!(
+        "/api/release_notes/v2/{}/{}",
+        release_channel.dev_name(),
+        version
+    ));
+
+    let markdown = workspace
+        .app_state()
+        .languages
+        .language_for_name("Markdown");
+
+    workspace
+        .with_local_workspace(cx, move |_, cx| {
+            cx.spawn(|workspace, mut cx| async move {
+                let markdown = markdown.await.log_err();
+                let response = client.get(&url, Default::default(), true).await;
+                let Some(mut response) = response.log_err() else {
+                    return;
+                };
+
+                let mut body = Vec::new();
+                response.body_mut().read_to_end(&mut body).await.ok();
+
+                let body: serde_json::Result<ReleaseNotesBody> =
+                    serde_json::from_slice(body.as_slice());
+
+                if let Ok(body) = body {
+                    workspace
+                        .update(&mut cx, |workspace, cx| {
+                            let project = workspace.project().clone();
+                            let buffer = project.update(cx, |project, cx| {
+                                project.create_local_buffer("", markdown, cx)
+                            });
+                            buffer.update(cx, |buffer, cx| {
+                                buffer.edit([(0..0, body.release_notes)], None, cx)
+                            });
+                            let language_registry = project.read(cx).languages().clone();
+
+                            let buffer = cx.new_model(|cx| MultiBuffer::singleton(buffer, cx));
+
+                            let tab_description = SharedString::from(body.title.to_string());
+                            let editor = cx.new_view(|cx| {
+                                Editor::for_multibuffer(buffer, Some(project), true, cx)
+                            });
+                            let workspace_handle = workspace.weak_handle();
+                            let view: View<MarkdownPreviewView> = MarkdownPreviewView::new(
+                                MarkdownPreviewMode::Default,
+                                editor,
+                                workspace_handle,
+                                language_registry,
+                                Some(tab_description),
+                                cx,
+                            );
+                            workspace.add_item_to_active_pane(
+                                Box::new(view.clone()),
+                                None,
+                                true,
+                                cx,
+                            );
+                            cx.notify();
+                        })
+                        .log_err();
+                }
+            })
+            .detach();
+        })
+        .detach();
+}
+
+pub fn notify_of_any_new_update(cx: &mut ViewContext<Workspace>) -> Option<()> {
+    let updater = AutoUpdater::get(cx)?;
+    let version = updater.read(cx).current_version();
+    let should_show_notification = updater.read(cx).should_show_update_notification(cx);
+
+    cx.spawn(|workspace, mut cx| async move {
+        let should_show_notification = should_show_notification.await?;
+        if should_show_notification {
+            workspace.update(&mut cx, |workspace, cx| {
+                let workspace_handle = workspace.weak_handle();
+                workspace.show_notification(
+                    NotificationId::unique::<UpdateNotification>(),
+                    cx,
+                    |cx| cx.new_view(|_| UpdateNotification::new(version, workspace_handle)),
+                );
+                updater.update(cx, |updater, cx| {
+                    updater
+                        .set_should_show_update_notification(false, cx)
+                        .detach_and_log_err(cx);
+                });
+            })?;
+        }
+        anyhow::Ok(())
+    })
+    .detach();
+
+    None
+}
--- a/crates/auto_update_ui/src/update_notification.rs
+++ b/crates/auto_update_ui/src/update_notification.rs
--- a/crates/channel/src/channel_store_tests.rs
+++ b/crates/channel/src/channel_store_tests.rs
@@ -343,7 +343,7 @@ fn init_test(cx: &mut AppContext) -> Model<ChannelStore> {
    release_channel::init(SemanticVersion::default(), cx);
    client::init_settings(cx);

-    let clock = Arc::new(FakeSystemClock::default());
+    let clock = Arc::new(FakeSystemClock::new());
    let http = FakeHttpClient::with_404_response();
    let client = Client::new(clock, http.clone(), cx);
    let user_store = cx.new_model(|cx| UserStore::new(client.clone(), cx));
--- a/crates/client/Cargo.toml
+++ b/crates/client/Cargo.toml
@@ -42,7 +42,6 @@ serde_json.workspace = true
 settings.workspace = true
 sha2.workspace = true
 smol.workspace = true
-sysinfo.workspace = true
 telemetry_events.workspace = true
 text.workspace = true
 thiserror.workspace = true
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -1780,7 +1780,7 @@ mod tests {
        let user_id = 5;
        let client = cx.update(|cx| {
            Client::new(
-                Arc::new(FakeSystemClock::default()),
+                Arc::new(FakeSystemClock::new()),
                FakeHttpClient::with_404_response(),
                cx,
            )
@@ -1821,7 +1821,7 @@ mod tests {
        let user_id = 5;
        let client = cx.update(|cx| {
            Client::new(
-                Arc::new(FakeSystemClock::default()),
+                Arc::new(FakeSystemClock::new()),
                FakeHttpClient::with_404_response(),
                cx,
            )
@@ -1900,7 +1900,7 @@ mod tests {
        let dropped_auth_count = Arc::new(Mutex::new(0));
        let client = cx.update(|cx| {
            Client::new(
-                Arc::new(FakeSystemClock::default()),
+                Arc::new(FakeSystemClock::new()),
                FakeHttpClient::with_404_response(),
                cx,
            )
@@ -1943,7 +1943,7 @@ mod tests {
        let user_id = 5;
        let client = cx.update(|cx| {
            Client::new(
-                Arc::new(FakeSystemClock::default()),
+                Arc::new(FakeSystemClock::new()),
                FakeHttpClient::with_404_response(),
                cx,
            )
@@ -2003,7 +2003,7 @@ mod tests {
        let user_id = 5;
        let client = cx.update(|cx| {
            Client::new(
-                Arc::new(FakeSystemClock::default()),
+                Arc::new(FakeSystemClock::new()),
                FakeHttpClient::with_404_response(),
                cx,
            )
@@ -2038,7 +2038,7 @@ mod tests {
        let user_id = 5;
        let client = cx.update(|cx| {
            Client::new(
-                Arc::new(FakeSystemClock::default()),
+                Arc::new(FakeSystemClock::new()),
                FakeHttpClient::with_404_response(),
                cx,
            )
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -2,7 +2,6 @@ mod event_coalescer;

 use crate::{ChannelId, TelemetrySettings};
 use anyhow::Result;
-use chrono::{DateTime, Utc};
 use clock::SystemClock;
 use collections::{HashMap, HashSet};
 use futures::Future;
@@ -15,12 +14,11 @@ use settings::{Settings, SettingsStore};
 use sha2::{Digest, Sha256};
 use std::fs::File;
 use std::io::Write;
+use std::time::Instant;
 use std::{env, mem, path::PathBuf, sync::Arc, time::Duration};
-use sysinfo::{CpuRefreshKind, Pid, ProcessRefreshKind, RefreshKind, System};
 use telemetry_events::{
-    ActionEvent, AppEvent, AssistantEvent, CallEvent, CpuEvent, EditEvent, EditorEvent, Event,
-    EventRequestBody, EventWrapper, ExtensionEvent, InlineCompletionEvent, MemoryEvent, ReplEvent,
-    SettingEvent,
+    ActionEvent, AppEvent, AssistantEvent, CallEvent, EditEvent, EditorEvent, Event,
+    EventRequestBody, EventWrapper, ExtensionEvent, InlineCompletionEvent, ReplEvent, SettingEvent,
 };
 use util::{ResultExt, TryFutureExt};
 use worktree::{UpdatedEntriesSet, WorktreeId};
@@ -46,7 +44,7 @@ struct TelemetryState {
    flush_events_task: Option<Task<()>>,
    log_file: Option<File>,
    is_staff: Option<bool>,
-    first_event_date_time: Option<DateTime<Utc>>,
+    first_event_date_time: Option<Instant>,
    event_coalescer: EventCoalescer,
    max_queue_size: usize,
    worktree_id_map: WorktreeIdMap,
@@ -226,6 +224,8 @@ impl Telemetry {
        cx.background_executor()
            .spawn({
                let state = state.clone();
+                let os_version = os_version();
+                state.lock().os_version = Some(os_version.clone());
                async move {
                    if let Some(tempfile) = File::create(Self::log_file_path()).log_err() {
                        state.lock().log_file = Some(tempfile);
@@ -293,55 +293,13 @@ impl Telemetry {
        state.session_id = Some(session_id);
        state.app_version = release_channel::AppVersion::global(cx).to_string();
        state.os_name = os_name();
-
-        drop(state);
-
-        let this = self.clone();
-        cx.background_executor()
-            .spawn(async move {
-                let mut system = System::new_with_specifics(
-                    RefreshKind::new().with_cpu(CpuRefreshKind::everything()),
-                );
-
-                let refresh_kind = ProcessRefreshKind::new().with_cpu().with_memory();
-                let current_process = Pid::from_u32(std::process::id());
-                system.refresh_processes_specifics(
-                    sysinfo::ProcessesToUpdate::Some(&[current_process]),
-                    refresh_kind,
-                );
-
-                // Waiting some amount of time before the first query is important to get a reasonable value
-                // https://docs.rs/sysinfo/0.29.10/sysinfo/trait.ProcessExt.html#tymethod.cpu_usage
-                const DURATION_BETWEEN_SYSTEM_EVENTS: Duration = Duration::from_secs(4 * 60);
-
-                loop {
-                    smol::Timer::after(DURATION_BETWEEN_SYSTEM_EVENTS).await;
-
-                    let current_process = Pid::from_u32(std::process::id());
-                    system.refresh_processes_specifics(
-                        sysinfo::ProcessesToUpdate::Some(&[current_process]),
-                        refresh_kind,
-                    );
-                    let Some(process) = system.process(current_process) else {
-                        log::error!(
-                            "Failed to find own process {current_process:?} in system process table"
-                        );
-                        // TODO: Fire an error telemetry event
-                        return;
-                    };
-
-                    this.report_memory_event(process.memory(), process.virtual_memory());
-                    this.report_cpu_event(process.cpu_usage(), system.cpus().len() as u32);
-                }
-            })
-            .detach();
    }

    pub fn metrics_enabled(self: &Arc<Self>) -> bool {
        let state = self.state.lock();
        let enabled = state.settings.metrics;
        drop(state);
-        return enabled;
+        enabled
    }

    pub fn set_authenticated_user_info(
@@ -416,28 +374,6 @@ impl Telemetry {
        self.report_event(event)
    }

-    pub fn report_cpu_event(self: &Arc<Self>, usage_as_percentage: f32, core_count: u32) {
-        let event = Event::Cpu(CpuEvent {
-            usage_as_percentage,
-            core_count,
-        });
-
-        self.report_event(event)
-    }
-
-    pub fn report_memory_event(
-        self: &Arc<Self>,
-        memory_in_bytes: u64,
-        virtual_memory_in_bytes: u64,
-    ) {
-        let event = Event::Memory(MemoryEvent {
-            memory_in_bytes,
-            virtual_memory_in_bytes,
-        });
-
-        self.report_event(event)
-    }
-
    pub fn report_app_event(self: &Arc<Self>, operation: String) -> Event {
        let event = Event::App(AppEvent { operation });

@@ -469,7 +405,10 @@ impl Telemetry {

        if let Some((start, end, environment)) = period_data {
            let event = Event::Edit(EditEvent {
-                duration: end.timestamp_millis() - start.timestamp_millis(),
+                duration: end
+                    .saturating_duration_since(start)
+                    .min(Duration::from_secs(60 * 60 * 24))
+                    .as_millis() as i64,
                environment: environment.to_string(),
                is_via_ssh,
            });
@@ -567,9 +506,10 @@ impl Telemetry {
        let date_time = self.clock.utc_now();

        let milliseconds_since_first_event = match state.first_event_date_time {
-            Some(first_event_date_time) => {
-                date_time.timestamp_millis() - first_event_date_time.timestamp_millis()
-            }
+            Some(first_event_date_time) => date_time
+                .saturating_duration_since(first_event_date_time)
+                .min(Duration::from_secs(60 * 60 * 24))
+                .as_millis() as i64,
            None => {
                state.first_event_date_time = Some(date_time);
                0
@@ -702,7 +642,6 @@ pub fn calculate_json_checksum(json: &impl AsRef<[u8]>) -> Option<String> {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use chrono::TimeZone;
    use clock::FakeSystemClock;
    use gpui::TestAppContext;
    use http_client::FakeHttpClient;
@@ -710,9 +649,7 @@ mod tests {
    #[gpui::test]
    fn test_telemetry_flush_on_max_queue_size(cx: &mut TestAppContext) {
        init_test(cx);
-        let clock = Arc::new(FakeSystemClock::new(
-            Utc.with_ymd_and_hms(1990, 4, 12, 12, 0, 0).unwrap(),
-        ));
+        let clock = Arc::new(FakeSystemClock::new());
        let http = FakeHttpClient::with_200_response();
        let system_id = Some("system_id".to_string());
        let installation_id = Some("installation_id".to_string());
@@ -743,7 +680,7 @@ mod tests {
                Some(first_date_time)
            );

-            clock.advance(chrono::Duration::milliseconds(100));
+            clock.advance(Duration::from_millis(100));

            let event = telemetry.report_app_event(operation.clone());
            assert_eq!(
@@ -759,7 +696,7 @@ mod tests {
                Some(first_date_time)
            );

-            clock.advance(chrono::Duration::milliseconds(100));
+            clock.advance(Duration::from_millis(100));

            let event = telemetry.report_app_event(operation.clone());
            assert_eq!(
@@ -775,7 +712,7 @@ mod tests {
                Some(first_date_time)
            );

-            clock.advance(chrono::Duration::milliseconds(100));
+            clock.advance(Duration::from_millis(100));

            // Adding a 4th event should cause a flush
            let event = telemetry.report_app_event(operation.clone());
@@ -796,9 +733,7 @@ mod tests {
        cx: &mut TestAppContext,
    ) {
        init_test(cx);
-        let clock = Arc::new(FakeSystemClock::new(
-            Utc.with_ymd_and_hms(1990, 4, 12, 12, 0, 0).unwrap(),
-        ));
+        let clock = Arc::new(FakeSystemClock::new());
        let http = FakeHttpClient::with_200_response();
        let system_id = Some("system_id".to_string());
        let installation_id = Some("installation_id".to_string());
--- a/crates/client/src/telemetry/event_coalescer.rs
+++ b/crates/client/src/telemetry/event_coalescer.rs
@@ -1,7 +1,6 @@
-use std::sync::Arc;
 use std::time;
+use std::{sync::Arc, time::Instant};

-use chrono::{DateTime, Duration, Utc};
 use clock::SystemClock;

 const COALESCE_TIMEOUT: time::Duration = time::Duration::from_secs(20);
@@ -10,8 +9,8 @@ const SIMULATED_DURATION_FOR_SINGLE_EVENT: time::Duration = time::Duration::from
 #[derive(Debug, PartialEq)]
 struct PeriodData {
    environment: &'static str,
-    start: DateTime<Utc>,
-    end: Option<DateTime<Utc>>,
+    start: Instant,
+    end: Option<Instant>,
 }

 pub struct EventCoalescer {
@@ -27,9 +26,8 @@ impl EventCoalescer {
    pub fn log_event(
        &mut self,
        environment: &'static str,
-    ) -> Option<(DateTime<Utc>, DateTime<Utc>, &'static str)> {
+    ) -> Option<(Instant, Instant, &'static str)> {
        let log_time = self.clock.utc_now();
-        let coalesce_timeout = Duration::from_std(COALESCE_TIMEOUT).unwrap();

        let Some(state) = &mut self.state else {
            self.state = Some(PeriodData {
@@ -43,7 +41,7 @@ impl EventCoalescer {
        let period_end = state
            .end
            .unwrap_or(state.start + SIMULATED_DURATION_FOR_SINGLE_EVENT);
-        let within_timeout = log_time - period_end < coalesce_timeout;
+        let within_timeout = log_time - period_end < COALESCE_TIMEOUT;
        let environment_is_same = state.environment == environment;
        let should_coaelesce = !within_timeout || !environment_is_same;

@@ -70,16 +68,13 @@ impl EventCoalescer {

 #[cfg(test)]
 mod tests {
-    use chrono::TimeZone;
    use clock::FakeSystemClock;

    use super::*;

    #[test]
    fn test_same_context_exceeding_timeout() {
-        let clock = Arc::new(FakeSystemClock::new(
-            Utc.with_ymd_and_hms(1990, 4, 12, 0, 0, 0).unwrap(),
-        ));
+        let clock = Arc::new(FakeSystemClock::new());
        let environment_1 = "environment_1";
        let mut event_coalescer = EventCoalescer::new(clock.clone());

@@ -98,7 +93,7 @@ mod tests {
            })
        );

-        let within_timeout_adjustment = Duration::from_std(COALESCE_TIMEOUT / 2).unwrap();
+        let within_timeout_adjustment = COALESCE_TIMEOUT / 2;

        // Ensure that many calls within the timeout don't start a new period
        for _ in 0..100 {
@@ -118,7 +113,7 @@ mod tests {
        }

        let period_end = clock.utc_now();
-        let exceed_timeout_adjustment = Duration::from_std(COALESCE_TIMEOUT * 2).unwrap();
+        let exceed_timeout_adjustment = COALESCE_TIMEOUT * 2;
        // Logging an event exceeding the timeout should start a new period
        clock.advance(exceed_timeout_adjustment);
        let new_period_start = clock.utc_now();
@@ -137,9 +132,7 @@ mod tests {

    #[test]
    fn test_different_environment_under_timeout() {
-        let clock = Arc::new(FakeSystemClock::new(
-            Utc.with_ymd_and_hms(1990, 4, 12, 0, 0, 0).unwrap(),
-        ));
+        let clock = Arc::new(FakeSystemClock::new());
        let environment_1 = "environment_1";
        let mut event_coalescer = EventCoalescer::new(clock.clone());

@@ -158,7 +151,7 @@ mod tests {
            })
        );

-        let within_timeout_adjustment = Duration::from_std(COALESCE_TIMEOUT / 2).unwrap();
+        let within_timeout_adjustment = COALESCE_TIMEOUT / 2;
        clock.advance(within_timeout_adjustment);
        let period_end = clock.utc_now();
        let period_data = event_coalescer.log_event(environment_1);
@@ -193,9 +186,7 @@ mod tests {

    #[test]
    fn test_switching_environment_while_within_timeout() {
-        let clock = Arc::new(FakeSystemClock::new(
-            Utc.with_ymd_and_hms(1990, 4, 12, 0, 0, 0).unwrap(),
-        ));
+        let clock = Arc::new(FakeSystemClock::new());
        let environment_1 = "environment_1";
        let mut event_coalescer = EventCoalescer::new(clock.clone());

@@ -214,7 +205,7 @@ mod tests {
            })
        );

-        let within_timeout_adjustment = Duration::from_std(COALESCE_TIMEOUT / 2).unwrap();
+        let within_timeout_adjustment = COALESCE_TIMEOUT / 2;
        clock.advance(within_timeout_adjustment);
        let period_end = clock.utc_now();
        let environment_2 = "environment_2";
@@ -240,9 +231,7 @@ mod tests {

    #[test]
    fn test_switching_environment_while_exceeding_timeout() {
-        let clock = Arc::new(FakeSystemClock::new(
-            Utc.with_ymd_and_hms(1990, 4, 12, 0, 0, 0).unwrap(),
-        ));
+        let clock = Arc::new(FakeSystemClock::new());
        let environment_1 = "environment_1";
        let mut event_coalescer = EventCoalescer::new(clock.clone());

@@ -261,7 +250,7 @@ mod tests {
            })
        );

-        let exceed_timeout_adjustment = Duration::from_std(COALESCE_TIMEOUT * 2).unwrap();
+        let exceed_timeout_adjustment = COALESCE_TIMEOUT * 2;
        clock.advance(exceed_timeout_adjustment);
        let period_end = clock.utc_now();
        let environment_2 = "environment_2";
--- a/crates/clock/Cargo.toml
+++ b/crates/clock/Cargo.toml
@@ -16,7 +16,6 @@ doctest = false
 test-support = ["dep:parking_lot"]

 [dependencies]
-chrono.workspace = true
 parking_lot = { workspace = true, optional = true }
 serde.workspace = true
 smallvec.workspace = true
--- a/crates/clock/src/system_clock.rs
+++ b/crates/clock/src/system_clock.rs
@@ -1,21 +1,21 @@
-use chrono::{DateTime, Utc};
+use std::time::Instant;

 pub trait SystemClock: Send + Sync {
    /// Returns the current date and time in UTC.
-    fn utc_now(&self) -> DateTime<Utc>;
+    fn utc_now(&self) -> Instant;
 }

 pub struct RealSystemClock;

 impl SystemClock for RealSystemClock {
-    fn utc_now(&self) -> DateTime<Utc> {
-        Utc::now()
+    fn utc_now(&self) -> Instant {
+        Instant::now()
    }
 }

 #[cfg(any(test, feature = "test-support"))]
 pub struct FakeSystemClockState {
-    now: DateTime<Utc>,
+    now: Instant,
 }

 #[cfg(any(test, feature = "test-support"))]
@@ -24,36 +24,30 @@ pub struct FakeSystemClock {
    state: parking_lot::Mutex<FakeSystemClockState>,
 }

-#[cfg(any(test, feature = "test-support"))]
-impl Default for FakeSystemClock {
-    fn default() -> Self {
-        Self::new(Utc::now())
-    }
-}
-
 #[cfg(any(test, feature = "test-support"))]
 impl FakeSystemClock {
-    pub fn new(now: DateTime<Utc>) -> Self {
-        let state = FakeSystemClockState { now };
+    pub fn new() -> Self {
+        let state = FakeSystemClockState {
+            now: Instant::now(),
+        };

        Self {
            state: parking_lot::Mutex::new(state),
        }
    }

-    pub fn set_now(&self, now: DateTime<Utc>) {
+    pub fn set_now(&self, now: Instant) {
        self.state.lock().now = now;
    }

-    /// Advances the [`FakeSystemClock`] by the specified [`Duration`](chrono::Duration).
-    pub fn advance(&self, duration: chrono::Duration) {
+    pub fn advance(&self, duration: std::time::Duration) {
        self.state.lock().now += duration;
    }
 }

 #[cfg(any(test, feature = "test-support"))]
 impl SystemClock for FakeSystemClock {
-    fn utc_now(&self) -> DateTime<Utc> {
+    fn utc_now(&self) -> Instant {
        self.state.lock().now
    }
 }
--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -24,6 +24,7 @@ async-stripe.workspace = true
 async-tungstenite.workspace = true
 aws-config = { version = "1.1.5" }
 aws-sdk-s3 = { version = "1.15.0" }
+aws-sdk-kinesis = "1.51.0"
 axum = { version = "0.6", features = ["json", "headers", "ws"] }
 axum-extra = { version = "0.4", features = ["erased-json"] }
 base64.workspace = true
@@ -89,6 +90,7 @@ collections = { workspace = true, features = ["test-support"] }
 ctor.workspace = true
 editor = { workspace = true, features = ["test-support"] }
 env_logger.workspace = true
+extension.workspace = true
 file_finder.workspace = true
 fs = { workspace = true, features = ["test-support"] }
 git = { workspace = true, features = ["test-support"] }
--- a/crates/collab/k8s/collab.template.yml
+++ b/crates/collab/k8s/collab.template.yml
@@ -174,6 +174,31 @@ spec:
                secretKeyRef:
                  name: blob-store
                  key: bucket
+            - name: KINESIS_ACCESS_KEY
+              valueFrom:
+                secretKeyRef:
+                  name: kinesis
+                  key: access_key
+            - name: KINESIS_SECRET_KEY
+              valueFrom:
+                secretKeyRef:
+                  name: kinesis
+                  key: secret_key
+            - name: KINESIS_STREAM
+              valueFrom:
+                secretKeyRef:
+                  name: kinesis
+                  key: stream
+            - name: KINESIS_REGION
+              valueFrom:
+                secretKeyRef:
+                  name: kinesis
+                  key: region
+            - name: BLOB_STORE_BUCKET
+              valueFrom:
+                secretKeyRef:
+                  name: blob-store
+                  key: bucket
            - name: CLICKHOUSE_URL
              valueFrom:
                secretKeyRef:
--- a/crates/collab/src/api/events.rs
+++ b/crates/collab/src/api/events.rs
@@ -11,9 +11,11 @@ use axum::{
    routing::post,
    Extension, Router, TypedHeader,
 };
+use chrono::Duration;
 use rpc::ExtensionMetadata;
 use semantic_version::SemanticVersion;
-use serde::{Serialize, Serializer};
+use serde::{Deserialize, Serialize, Serializer};
+use serde_json::json;
 use sha2::{Digest, Sha256};
 use std::sync::{Arc, OnceLock};
 use telemetry_events::{
@@ -21,6 +23,7 @@ use telemetry_events::{
    EventRequestBody, EventWrapper, ExtensionEvent, InlineCompletionEvent, MemoryEvent, Panic,
    ReplEvent, SettingEvent,
 };
+use util::ResultExt;
 use uuid::Uuid;

 const CRASH_REPORTS_BUCKET: &str = "zed-crash-reports";
@@ -388,13 +391,6 @@ pub async fn post_events(
    country_code_header: Option<TypedHeader<CloudflareIpCountryHeader>>,
    body: Bytes,
 ) -> Result<()> {
-    let Some(clickhouse_client) = app.clickhouse_client.clone() else {
-        Err(Error::http(
-            StatusCode::NOT_IMPLEMENTED,
-            "not supported".into(),
-        ))?
-    };
-
    let Some(expected) = calculate_json_checksum(app.clone(), &body) else {
        return Err(Error::http(
            StatusCode::INTERNAL_SERVER_ERROR,
@@ -416,6 +412,34 @@ pub async fn post_events(
    };
    let country_code = country_code_header.map(|h| h.to_string());

+    let first_event_at = chrono::Utc::now()
+        - chrono::Duration::milliseconds(last_event.milliseconds_since_first_event);
+
+    if let Some(kinesis_client) = app.kinesis_client.clone() {
+        if let Some(stream) = app.config.kinesis_stream.clone() {
+            let mut request = kinesis_client.put_records().stream_name(stream);
+            for row in for_snowflake(request_body.clone(), first_event_at, country_code.clone()) {
+                if let Some(data) = serde_json::to_vec(&row).log_err() {
+                    request = request.records(
+                        aws_sdk_kinesis::types::PutRecordsRequestEntry::builder()
+                            .partition_key(request_body.system_id.clone().unwrap_or_default())
+                            .data(data.into())
+                            .build()
+                            .unwrap(),
+                    );
+                }
+            }
+            request.send().await.log_err();
+        }
+    };
+
+    let Some(clickhouse_client) = app.clickhouse_client.clone() else {
+        Err(Error::http(
+            StatusCode::NOT_IMPLEMENTED,
+            "not supported".into(),
+        ))?
+    };
+
    let first_event_at = chrono::Utc::now()
        - chrono::Duration::milliseconds(last_event.milliseconds_since_first_event);

@@ -459,20 +483,7 @@ pub async fn post_events(
                        checksum_matched,
                    ))
            }
-            Event::Cpu(event) => to_upload.cpu_events.push(CpuEventRow::from_event(
-                event.clone(),
-                wrapper,
-                &request_body,
-                first_event_at,
-                checksum_matched,
-            )),
-            Event::Memory(event) => to_upload.memory_events.push(MemoryEventRow::from_event(
-                event.clone(),
-                wrapper,
-                &request_body,
-                first_event_at,
-                checksum_matched,
-            )),
+            Event::Cpu(_) | Event::Memory(_) => continue,
            Event::App(event) => to_upload.app_events.push(AppEventRow::from_event(
                event.clone(),
                wrapper,
@@ -923,6 +934,7 @@ pub struct CpuEventRow {
 }

 impl CpuEventRow {
+    #[allow(unused)]
    fn from_event(
        event: CpuEvent,
        wrapper: &EventWrapper,
@@ -977,6 +989,7 @@ pub struct MemoryEventRow {
 }

 impl MemoryEventRow {
+    #[allow(unused)]
    fn from_event(
        event: MemoryEvent,
        wrapper: &EventWrapper,
@@ -1364,3 +1377,214 @@ pub fn calculate_json_checksum(app: Arc<AppState>, json: &impl AsRef<[u8]>) -> O
    summer.update(checksum_seed);
    Some(summer.finalize().into_iter().collect())
 }
+
+fn for_snowflake(
+    body: EventRequestBody,
+    first_event_at: chrono::DateTime<chrono::Utc>,
+    country_code: Option<String>,
+) -> impl Iterator<Item = SnowflakeRow> {
+    body.events.into_iter().flat_map(move |event| {
+        let timestamp =
+            first_event_at + Duration::milliseconds(event.milliseconds_since_first_event);
+        let (event_type, mut event_properties) = match &event.event {
+            Event::Editor(e) => (
+                match e.operation.as_str() {
+                    "open" => "Editor Opened".to_string(),
+                    "save" => "Editor Saved".to_string(),
+                    _ => format!("Unknown Editor Event: {}", e.operation),
+                },
+                serde_json::to_value(e).unwrap(),
+            ),
+            Event::InlineCompletion(e) => (
+                format!(
+                    "Inline Completion {}",
+                    if e.suggestion_accepted {
+                        "Accepted"
+                    } else {
+                        "Discarded"
+                    }
+                ),
+                serde_json::to_value(e).unwrap(),
+            ),
+            Event::Call(e) => {
+                let event_type = match e.operation.trim() {
+                    "unshare project" => "Project Unshared".to_string(),
+                    "open channel notes" => "Channel Notes Opened".to_string(),
+                    "share project" => "Project Shared".to_string(),
+                    "join channel" => "Channel Joined".to_string(),
+                    "hang up" => "Call Ended".to_string(),
+                    "accept incoming" => "Incoming Call Accepted".to_string(),
+                    "invite" => "Participant Invited".to_string(),
+                    "disable microphone" => "Microphone Disabled".to_string(),
+                    "enable microphone" => "Microphone Enabled".to_string(),
+                    "enable screen share" => "Screen Share Enabled".to_string(),
+                    "disable screen share" => "Screen Share Disabled".to_string(),
+                    "decline incoming" => "Incoming Call Declined".to_string(),
+                    "enable camera" => "Camera Enabled".to_string(),
+                    "disable camera" => "Camera Disabled".to_string(),
+                    _ => format!("Unknown Call Event: {}", e.operation),
+                };
+
+                (event_type, serde_json::to_value(e).unwrap())
+            }
+            Event::Assistant(e) => (
+                match e.phase {
+                    telemetry_events::AssistantPhase::Response => "Assistant Responded".to_string(),
+                    telemetry_events::AssistantPhase::Invoked => "Assistant Invoked".to_string(),
+                    telemetry_events::AssistantPhase::Accepted => {
+                        "Assistant Response Accepted".to_string()
+                    }
+                    telemetry_events::AssistantPhase::Rejected => {
+                        "Assistant Response Rejected".to_string()
+                    }
+                },
+                serde_json::to_value(e).unwrap(),
+            ),
+            Event::Cpu(_) | Event::Memory(_) => return None,
+            Event::App(e) => {
+                let mut properties = json!({});
+                let event_type = match e.operation.trim() {
+                    "extensions: install extension" => "Extension Installed".to_string(),
+                    "open" => "App Opened".to_string(),
+                    "project search: open" => "Project Search Opened".to_string(),
+                    "first open" => {
+                        properties["is_first_open"] = json!(true);
+                        "App First Opened".to_string()
+                    }
+                    "extensions: uninstall extension" => "Extension Uninstalled".to_string(),
+                    "welcome page: close" => "Welcome Page Closed".to_string(),
+                    "open project" => {
+                        properties["is_first_time"] = json!(false);
+                        "Project Opened".to_string()
+                    }
+                    "welcome page: install cli" => "CLI Installed".to_string(),
+                    "project diagnostics: open" => "Project Diagnostics Opened".to_string(),
+                    "extensions page: open" => "Extensions Page Opened".to_string(),
+                    "welcome page: change theme" => "Welcome Theme Changed".to_string(),
+                    "welcome page: toggle metric telemetry" => {
+                        properties["enabled"] = json!(false);
+                        "Welcome Telemetry Toggled".to_string()
+                    }
+                    "welcome page: change keymap" => "Keymap Changed".to_string(),
+                    "welcome page: toggle vim" => {
+                        properties["enabled"] = json!(false);
+                        "Welcome Vim Mode Toggled".to_string()
+                    }
+                    "welcome page: sign in to copilot" => "Welcome Copilot Signed In".to_string(),
+                    "welcome page: toggle diagnostic telemetry" => {
+                        "Welcome Telemetry Toggled".to_string()
+                    }
+                    "welcome page: open" => "Welcome Page Opened".to_string(),
+                    "close" => "App Closed".to_string(),
+                    "markdown preview: open" => "Markdown Preview Opened".to_string(),
+                    "welcome page: open extensions" => "Extensions Page Opened".to_string(),
+                    "open node project" | "open pnpm project" | "open yarn project" => {
+                        properties["project_type"] = json!("node");
+                        properties["is_first_time"] = json!(false);
+                        "Project Opened".to_string()
+                    }
+                    "repl sessions: open" => "REPL Session Started".to_string(),
+                    "welcome page: toggle helix" => {
+                        properties["enabled"] = json!(false);
+                        "Helix Mode Toggled".to_string()
+                    }
+                    "welcome page: edit settings" => {
+                        properties["changed_settings"] = json!([]);
+                        "Settings Edited".to_string()
+                    }
+                    "welcome page: view docs" => "Documentation Viewed".to_string(),
+                    "open ssh project" => {
+                        properties["is_first_time"] = json!(false);
+                        "SSH Project Opened".to_string()
+                    }
+                    "create ssh server" => "SSH Server Created".to_string(),
+                    "create ssh project" => "SSH Project Created".to_string(),
+                    "first open for release channel" => {
+                        properties["is_first_for_channel"] = json!(true);
+                        "App First Opened For Release Channel".to_string()
+                    }
+                    "feature upsell: toggle vim" => {
+                        properties["source"] = json!("Feature Upsell");
+                        "Vim Mode Toggled".to_string()
+                    }
+                    _ => e
+                        .operation
+                        .strip_prefix("feature upsell: viewed docs (")
+                        .and_then(|s| s.strip_suffix(')'))
+                        .map_or_else(
+                            || format!("Unknown App Event: {}", e.operation),
+                            |docs_url| {
+                                properties["url"] = json!(docs_url);
+                                properties["source"] = json!("Feature Upsell");
+                                "Documentation Viewed".to_string()
+                            },
+                        ),
+                };
+                (event_type, properties)
+            }
+            Event::Setting(e) => (
+                "Settings Changed".to_string(),
+                serde_json::to_value(e).unwrap(),
+            ),
+            Event::Extension(e) => (
+                "Extension Loaded".to_string(),
+                serde_json::to_value(e).unwrap(),
+            ),
+            Event::Edit(e) => (
+                "Editor Edited".to_string(),
+                serde_json::to_value(e).unwrap(),
+            ),
+            Event::Action(e) => (
+                "Action Invoked".to_string(),
+                serde_json::to_value(e).unwrap(),
+            ),
+            Event::Repl(e) => (
+                "Kernel Status Changed".to_string(),
+                serde_json::to_value(e).unwrap(),
+            ),
+        };
+
+        if let serde_json::Value::Object(ref mut map) = event_properties {
+            map.insert("app_version".to_string(), body.app_version.clone().into());
+            map.insert("os_name".to_string(), body.os_name.clone().into());
+            map.insert("os_version".to_string(), body.os_version.clone().into());
+            map.insert("architecture".to_string(), body.architecture.clone().into());
+            map.insert(
+                "release_channel".to_string(),
+                body.release_channel.clone().into(),
+            );
+            map.insert("signed_in".to_string(), event.signed_in.into());
+            if let Some(country_code) = country_code.as_ref() {
+                map.insert("country".to_string(), country_code.clone().into());
+            }
+        }
+
+        // NOTE: most amplitude user properties are read out of our event_properties
+        // dictionary. See https://app.amplitude.com/data/zed/Zed/sources/detail/production/falcon%3A159998
+        // for how that is configured.
+        let user_properties = Some(serde_json::json!({
+            "is_staff": body.is_staff,
+        }));
+
+        Some(SnowflakeRow {
+            time: timestamp,
+            user_id: body.metrics_id.clone(),
+            device_id: body.system_id.clone(),
+            event_type,
+            event_properties,
+            user_properties,
+            insert_id: Some(Uuid::new_v4().to_string()),
+        })
+    })
+}
+
+#[derive(Serialize, Deserialize)]
+struct SnowflakeRow {
+    pub time: chrono::DateTime<chrono::Utc>,
+    pub user_id: Option<String>,
+    pub device_id: Option<String>,
+    pub event_type: String,
+    pub event_properties: serde_json::Value,
+    pub user_properties: Option<serde_json::Value>,
+    pub insert_id: Option<String>,
+}
--- a/crates/collab/src/lib.rs
+++ b/crates/collab/src/lib.rs
@@ -170,6 +170,10 @@ pub struct Config {
    pub blob_store_access_key: Option<String>,
    pub blob_store_secret_key: Option<String>,
    pub blob_store_bucket: Option<String>,
+    pub kinesis_region: Option<String>,
+    pub kinesis_stream: Option<String>,
+    pub kinesis_access_key: Option<String>,
+    pub kinesis_secret_key: Option<String>,
    pub zed_environment: Arc<str>,
    pub openai_api_key: Option<Arc<str>>,
    pub google_ai_api_key: Option<Arc<str>>,
@@ -238,6 +242,10 @@ impl Config {
            stripe_api_key: None,
            supermaven_admin_api_key: None,
            user_backfiller_github_access_token: None,
+            kinesis_region: None,
+            kinesis_access_key: None,
+            kinesis_secret_key: None,
+            kinesis_stream: None,
        }
    }
 }
@@ -276,6 +284,7 @@ pub struct AppState {
    pub rate_limiter: Arc<RateLimiter>,
    pub executor: Executor,
    pub clickhouse_client: Option<::clickhouse::Client>,
+    pub kinesis_client: Option<::aws_sdk_kinesis::Client>,
    pub config: Config,
 }

@@ -332,6 +341,11 @@ impl AppState {
                .clickhouse_url
                .as_ref()
                .and_then(|_| build_clickhouse_client(&config).log_err()),
+            kinesis_client: if config.kinesis_access_key.is_some() {
+                build_kinesis_client(&config).await.log_err()
+            } else {
+                None
+            },
            config,
        };
        Ok(Arc::new(this))
@@ -381,6 +395,35 @@ async fn build_blob_store_client(config: &Config) -> anyhow::Result<aws_sdk_s3::
    Ok(aws_sdk_s3::Client::new(&s3_config))
 }

+async fn build_kinesis_client(config: &Config) -> anyhow::Result<aws_sdk_kinesis::Client> {
+    let keys = aws_sdk_s3::config::Credentials::new(
+        config
+            .kinesis_access_key
+            .clone()
+            .ok_or_else(|| anyhow!("missing kinesis_access_key"))?,
+        config
+            .kinesis_secret_key
+            .clone()
+            .ok_or_else(|| anyhow!("missing kinesis_secret_key"))?,
+        None,
+        None,
+        "env",
+    );
+
+    let kinesis_config = aws_config::defaults(BehaviorVersion::latest())
+        .region(Region::new(
+            config
+                .kinesis_region
+                .clone()
+                .ok_or_else(|| anyhow!("missing blob_store_region"))?,
+        ))
+        .credentials_provider(keys)
+        .load()
+        .await;
+
+    Ok(aws_sdk_kinesis::Client::new(&kinesis_config))
+}
+
 fn build_clickhouse_client(config: &Config) -> anyhow::Result<::clickhouse::Client> {
    Ok(::clickhouse::Client::default()
        .with_url(
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -267,7 +267,6 @@ async fn perform_completion(
                anthropic::ANTHROPIC_API_URL,
                api_key,
                request,
-                None,
            )
            .await
            .map_err(|err| match err {
@@ -357,7 +356,6 @@ async fn perform_completion(
                open_ai::OPEN_AI_API_URL,
                api_key,
                serde_json::from_str(params.provider_request.get())?,
-                None,
            )
            .await?;

@@ -390,7 +388,6 @@ async fn perform_completion(
                google_ai::API_URL,
                api_key,
                serde_json::from_str(params.provider_request.get())?,
-                None,
            )
            .await?;

--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -3621,7 +3621,6 @@ async fn count_language_model_tokens(
                google_ai::API_URL,
                api_key,
                serde_json::from_str(&request.request)?,
-                None,
            )
            .await?
        }
@@ -4031,12 +4030,18 @@ async fn get_llm_api_token(
        Err(anyhow!("terms of service not accepted"))?
    }

-    let mut account_created_at = user.created_at;
-    if let Some(github_created_at) = user.github_user_created_at {
-        account_created_at = account_created_at.min(github_created_at);
-    }
-    if Utc::now().naive_utc() - account_created_at < MIN_ACCOUNT_AGE_FOR_LLM_USE {
-        Err(anyhow!("account too young"))?
+    let has_llm_subscription = session.has_llm_subscription(&db).await?;
+
+    let bypass_account_age_check =
+        has_llm_subscription || flags.iter().any(|flag| flag == "bypass-account-age-check");
+    if !bypass_account_age_check {
+        let mut account_created_at = user.created_at;
+        if let Some(github_created_at) = user.github_user_created_at {
+            account_created_at = account_created_at.min(github_created_at);
+        }
+        if Utc::now().naive_utc() - account_created_at < MIN_ACCOUNT_AGE_FOR_LLM_USE {
+            Err(anyhow!("account too young"))?
+        }
    }

    let billing_preferences = db.get_billing_preferences(user.id).await?;
@@ -4046,7 +4051,7 @@ async fn get_llm_api_token(
        session.is_staff(),
        billing_preferences,
        has_llm_closed_beta_feature_flag,
-        session.has_llm_subscription(&db).await?,
+        has_llm_subscription,
        session.current_plan(&db).await?,
        &session.app_state.config,
    )?;
--- a/crates/collab/src/tests/random_project_collaboration_tests.rs
+++ b/crates/collab/src/tests/random_project_collaboration_tests.rs
@@ -835,7 +835,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                        .map_ok(|_| ())
                        .boxed(),
                    LspRequestKind::CodeAction => project
-                        .code_actions(&buffer, offset..offset, cx)
+                        .code_actions(&buffer, offset..offset, None, cx)
                        .map(|_| Ok(()))
                        .boxed(),
                    LspRequestKind::Definition => project
@@ -1323,11 +1323,8 @@ impl RandomizedTest for ProjectCollaborationTest {
                    match (host_file, guest_file) {
                        (Some(host_file), Some(guest_file)) => {
                            assert_eq!(guest_file.path(), host_file.path());
-                            assert_eq!(guest_file.is_deleted(), host_file.is_deleted());
-                            assert_eq!(
-                                guest_file.mtime(),
-                                host_file.mtime(),
-                                "guest {} mtime does not match host {} for path {:?} in project {}",
+                            assert_eq!(guest_file.disk_state(), host_file.disk_state(),
+                                "guest {} disk_state does not match host {} for path {:?} in project {}",
                                guest_user_id,
                                host_user_id,
                                guest_file.path(),
--- a/crates/collab/src/tests/remote_editing_collaboration_tests.rs
+++ b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
@@ -1,6 +1,7 @@
 use crate::tests::TestServer;
 use call::ActiveCall;
 use collections::HashSet;
+use extension::ExtensionHostProxy;
 use fs::{FakeFs, Fs as _};
 use futures::StreamExt as _;
 use gpui::{BackgroundExecutor, Context as _, SemanticVersion, TestAppContext, UpdateGlobal as _};
@@ -81,6 +82,7 @@ async fn test_sharing_an_ssh_remote_project(
                http_client: remote_http_client,
                node_runtime: node,
                languages,
+                extension_host_proxy: Arc::new(ExtensionHostProxy::new()),
            },
            cx,
        )
@@ -243,6 +245,7 @@ async fn test_ssh_collaboration_git_branches(
                http_client: remote_http_client,
                node_runtime: node,
                languages,
+                extension_host_proxy: Arc::new(ExtensionHostProxy::new()),
            },
            cx,
        )
@@ -400,6 +403,7 @@ async fn test_ssh_collaboration_formatting_with_prettier(
                http_client: remote_http_client,
                node_runtime: NodeRuntime::unavailable(),
                languages,
+                extension_host_proxy: Arc::new(ExtensionHostProxy::new()),
            },
            cx,
        )
--- a/crates/collab/src/tests/test_server.rs
+++ b/crates/collab/src/tests/test_server.rs
@@ -168,7 +168,7 @@ impl TestServer {
            client::init_settings(cx);
        });

-        let clock = Arc::new(FakeSystemClock::default());
+        let clock = Arc::new(FakeSystemClock::new());
        let http = FakeHttpClient::with_404_response();
        let user_id = if let Ok(Some(user)) = self.app_state.db.get_user_by_github_login(name).await
        {
@@ -512,6 +512,7 @@ impl TestServer {
            rate_limiter: Arc::new(RateLimiter::new(test_db.db().clone())),
            executor,
            clickhouse_client: None,
+            kinesis_client: None,
            config: Config {
                http_port: 0,
                database_url: "".into(),
@@ -550,6 +551,10 @@ impl TestServer {
                stripe_api_key: None,
                supermaven_admin_api_key: None,
                user_backfiller_github_access_token: None,
+                kinesis_region: None,
+                kinesis_stream: None,
+                kinesis_access_key: None,
+                kinesis_secret_key: None,
            },
        })
    }
--- a/crates/collab_ui/Cargo.toml
+++ b/crates/collab_ui/Cargo.toml
@@ -58,12 +58,11 @@ settings.workspace = true
 smallvec.workspace = true
 story = { workspace = true, optional = true }
 theme.workspace = true
-time_format.workspace = true
 time.workspace = true
+time_format.workspace = true
 title_bar.workspace = true
 ui.workspace = true
 util.workspace = true
-vcs_menu.workspace = true
 workspace.workspace = true

 [dev-dependencies]
--- a/crates/collab_ui/src/chat_panel.rs
+++ b/crates/collab_ui/src/chat_panel.rs
@@ -23,7 +23,7 @@ use std::{sync::Arc, time::Duration};
 use time::{OffsetDateTime, UtcOffset};
 use ui::{
    prelude::*, Avatar, Button, ContextMenu, IconButton, IconName, KeyBinding, Label, PopoverMenu,
-    TabBar, Tooltip,
+    Tab, TabBar, Tooltip,
 };
 use util::{ResultExt, TryFutureExt};
 use workspace::{
@@ -939,7 +939,7 @@ impl Render for ChatPanel {
                    TabBar::new("chat_header").child(
                        h_flex()
                            .w_full()
-                            .h(rems(ui::Tab::CONTAINER_HEIGHT_IN_REMS))
+                            .h(Tab::container_height(cx))
                            .px_2()
                            .child(Label::new(
                                self.active_chat
--- a/crates/collab_ui/src/collab_panel.rs
+++ b/crates/collab_ui/src/collab_panel.rs
@@ -2521,7 +2521,7 @@ impl CollabPanel {
            .flex()
            .w_full()
            .when(!channel.is_root_channel(), |el| {
-                el.on_drag(channel.clone(), move |channel, cx| {
+                el.on_drag(channel.clone(), move |channel, _, cx| {
                    cx.new_view(|_| DraggedChannelView {
                        channel: channel.clone(),
                        width,
--- a/crates/collab_ui/src/collab_ui.rs
+++ b/crates/collab_ui/src/collab_ui.rs
@@ -33,7 +33,6 @@ pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
    notification_panel::init(cx);
    notifications::init(app_state, cx);
    title_bar::init(cx);
-    vcs_menu::init(cx);
 }

 fn notification_window_options(
--- a/crates/collab_ui/src/notification_panel.rs
+++ b/crates/collab_ui/src/notification_panel.rs
@@ -19,7 +19,9 @@ use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsStore};
 use std::{sync::Arc, time::Duration};
 use time::{OffsetDateTime, UtcOffset};
-use ui::{h_flex, prelude::*, v_flex, Avatar, Button, Icon, IconButton, IconName, Label, Tooltip};
+use ui::{
+    h_flex, prelude::*, v_flex, Avatar, Button, Icon, IconButton, IconName, Label, Tab, Tooltip,
+};
 use util::{ResultExt, TryFutureExt};
 use workspace::notifications::NotificationId;
 use workspace::{
@@ -588,7 +590,7 @@ impl Render for NotificationPanel {
                    .px_2()
                    .py_1()
                    // Match the height of the tab bar so they line up.
-                    .h(rems(ui::Tab::CONTAINER_HEIGHT_IN_REMS))
+                    .h(Tab::container_height(cx))
                    .border_b_1()
                    .border_color(cx.theme().colors().border)
                    .child(Label::new("Notifications"))
--- a/crates/command_palette/src/command_palette.rs
+++ b/crates/command_palette/src/command_palette.rs
@@ -11,7 +11,7 @@ use command_palette_hooks::{
 };
 use fuzzy::{StringMatch, StringMatchCandidate};
 use gpui::{
-    actions, Action, AppContext, DismissEvent, EventEmitter, FocusHandle, FocusableView, Global,
+    Action, AppContext, DismissEvent, EventEmitter, FocusHandle, FocusableView, Global,
    ParentElement, Render, Styled, Task, UpdateGlobal, View, ViewContext, VisualContext, WeakView,
 };
 use picker::{Picker, PickerDelegate};
@@ -21,9 +21,7 @@ use settings::Settings;
 use ui::{h_flex, prelude::*, v_flex, HighlightedLabel, KeyBinding, ListItem, ListItemSpacing};
 use util::ResultExt;
 use workspace::{ModalView, Workspace, WorkspaceSettings};
-use zed_actions::OpenZedUrl;
-
-actions!(command_palette, [Toggle]);
+use zed_actions::{command_palette::Toggle, OpenZedUrl};

 pub fn init(cx: &mut AppContext) {
    client::init_settings(cx);
--- a/crates/context_servers/Cargo.toml
+++ b/crates/context_servers/Cargo.toml
@@ -15,6 +15,7 @@ path = "src/context_servers.rs"
 anyhow.workspace = true
 collections.workspace = true
 command_palette_hooks.workspace = true
+extension.workspace = true
 futures.workspace = true
 gpui.workspace = true
 log.workspace = true
--- a/crates/context_servers/src/client.rs
+++ b/crates/context_servers/src/client.rs
@@ -9,7 +9,7 @@ use serde_json::{value::RawValue, Value};
 use smol::{
    channel,
    io::{AsyncBufReadExt, AsyncWriteExt, BufReader},
-    process::{self, Child},
+    process::Child,
 };
 use std::{
    fmt,
@@ -25,6 +25,13 @@ use util::TryFutureExt;
 const JSON_RPC_VERSION: &str = "2.0";
 const REQUEST_TIMEOUT: Duration = Duration::from_secs(60);

+// Standard JSON-RPC error codes
+pub const PARSE_ERROR: i32 = -32700;
+pub const INVALID_REQUEST: i32 = -32600;
+pub const METHOD_NOT_FOUND: i32 = -32601;
+pub const INVALID_PARAMS: i32 = -32602;
+pub const INTERNAL_ERROR: i32 = -32603;
+
 type ResponseHandler = Box<dyn Send + FnOnce(Result<String, Error>)>;
 type NotificationHandler = Box<dyn Send + FnMut(Value, AsyncAppContext)>;

@@ -145,7 +152,7 @@ impl Client {
            &binary.args
        );

-        let mut command = process::Command::new(&binary.executable);
+        let mut command = util::command::new_smol_command(&binary.executable);
        command
            .args(&binary.args)
            .envs(binary.env.unwrap_or_default())
--- a/crates/context_servers/src/context_servers.rs
+++ b/crates/context_servers/src/context_servers.rs
@@ -1,4 +1,5 @@
 pub mod client;
+mod extension_context_server;
 pub mod manager;
 pub mod protocol;
 mod registry;
@@ -19,6 +20,7 @@ pub const CONTEXT_SERVERS_NAMESPACE: &'static str = "context_servers";
 pub fn init(cx: &mut AppContext) {
    ContextServerSettings::register(cx);
    ContextServerFactoryRegistry::default_global(cx);
+    extension_context_server::init(cx);

    CommandPaletteFilter::update_global(cx, |filter, _cx| {
        filter.hide_namespace(CONTEXT_SERVERS_NAMESPACE);
--- a/crates/context_servers/src/extension_context_server.rs
+++ b/crates/context_servers/src/extension_context_server.rs
@@ -0,0 +1,78 @@
+use std::sync::Arc;
+
+use extension::{Extension, ExtensionContextServerProxy, ExtensionHostProxy, ProjectDelegate};
+use gpui::{AppContext, Model};
+
+use crate::manager::ServerCommand;
+use crate::ContextServerFactoryRegistry;
+
+struct ExtensionProject {
+    worktree_ids: Vec<u64>,
+}
+
+impl ProjectDelegate for ExtensionProject {
+    fn worktree_ids(&self) -> Vec<u64> {
+        self.worktree_ids.clone()
+    }
+}
+
+pub fn init(cx: &mut AppContext) {
+    let proxy = ExtensionHostProxy::default_global(cx);
+    proxy.register_context_server_proxy(ContextServerFactoryRegistryProxy {
+        context_server_factory_registry: ContextServerFactoryRegistry::global(cx),
+    });
+}
+
+struct ContextServerFactoryRegistryProxy {
+    context_server_factory_registry: Model<ContextServerFactoryRegistry>,
+}
+
+impl ExtensionContextServerProxy for ContextServerFactoryRegistryProxy {
+    fn register_context_server(
+        &self,
+        extension: Arc<dyn Extension>,
+        id: Arc<str>,
+        cx: &mut AppContext,
+    ) {
+        self.context_server_factory_registry
+            .update(cx, |registry, _| {
+                registry.register_server_factory(
+                    id.clone(),
+                    Arc::new({
+                        move |project, cx| {
+                            log::info!(
+                                "loading command for context server {id} from extension {}",
+                                extension.manifest().id
+                            );
+
+                            let id = id.clone();
+                            let extension = extension.clone();
+                            cx.spawn(|mut cx| async move {
+                                let extension_project =
+                                    project.update(&mut cx, |project, cx| {
+                                        Arc::new(ExtensionProject {
+                                            worktree_ids: project
+                                                .visible_worktrees(cx)
+                                                .map(|worktree| worktree.read(cx).id().to_proto())
+                                                .collect(),
+                                        })
+                                    })?;
+
+                                let command = extension
+                                    .context_server_command(id.clone(), extension_project)
+                                    .await?;
+
+                                log::info!("loaded command for context server {id}: {command:?}");
+
+                                Ok(ServerCommand {
+                                    path: command.command,
+                                    args: command.args,
+                                    env: Some(command.env.into_iter().collect()),
+                                })
+                            })
+                        }
+                    }),
+                )
+            });
+    }
+}
--- a/crates/context_servers/src/manager.rs
+++ b/crates/context_servers/src/manager.rs
@@ -24,6 +24,8 @@ use gpui::{AsyncAppContext, EventEmitter, Model, ModelContext, Subscription, Tas
 use log;
 use parking_lot::RwLock;
 use project::Project;
+use schemars::gen::SchemaGenerator;
+use schemars::schema::{InstanceType, Schema, SchemaObject};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources, SettingsStore};
@@ -36,16 +38,32 @@ use crate::{

 #[derive(Deserialize, Serialize, Default, Clone, PartialEq, Eq, JsonSchema, Debug)]
 pub struct ContextServerSettings {
+    /// Settings for context servers used in the Assistant.
    #[serde(default)]
    pub context_servers: HashMap<Arc<str>, ServerConfig>,
 }

 #[derive(Deserialize, Serialize, Clone, PartialEq, Eq, JsonSchema, Debug, Default)]
 pub struct ServerConfig {
+    /// The command to run this context server.
+    ///
+    /// This will override the command set by an extension.
    pub command: Option<ServerCommand>,
+    /// The settings for this context server.
+    ///
+    /// Consult the documentation for the context server to see what settings
+    /// are supported.
+    #[schemars(schema_with = "server_config_settings_json_schema")]
    pub settings: Option<serde_json::Value>,
 }

+fn server_config_settings_json_schema(_generator: &mut SchemaGenerator) -> Schema {
+    Schema::Object(SchemaObject {
+        instance_type: Some(InstanceType::Object.into()),
+        ..Default::default()
+    })
+}
+
 #[derive(Deserialize, Serialize, Clone, PartialEq, Eq, JsonSchema, Debug)]
 pub struct ServerCommand {
    pub path: String,
--- a/crates/context_servers/src/protocol.rs
+++ b/crates/context_servers/src/protocol.rs
@@ -11,8 +11,6 @@ use collections::HashMap;
 use crate::client::Client;
 use crate::types;

-const PROTOCOL_VERSION: &str = "2024-10-07";
-
 pub struct ModelContextProtocol {
    inner: Client,
 }
@@ -23,10 +21,9 @@ impl ModelContextProtocol {
    }

    fn supported_protocols() -> Vec<types::ProtocolVersion> {
-        vec![
-            types::ProtocolVersion::VersionString(PROTOCOL_VERSION.to_string()),
-            types::ProtocolVersion::VersionNumber(1),
-        ]
+        vec![types::ProtocolVersion(
+            types::LATEST_PROTOCOL_VERSION.to_string(),
+        )]
    }

    pub async fn initialize(
@@ -34,11 +31,13 @@ impl ModelContextProtocol {
        client_info: types::Implementation,
    ) -> Result<InitializedContextServerProtocol> {
        let params = types::InitializeParams {
-            protocol_version: types::ProtocolVersion::VersionString(PROTOCOL_VERSION.to_string()),
+            protocol_version: types::ProtocolVersion(types::LATEST_PROTOCOL_VERSION.to_string()),
            capabilities: types::ClientCapabilities {
                experimental: None,
                sampling: None,
+                roots: None,
            },
+            meta: None,
            client_info,
        };

@@ -148,6 +147,7 @@ impl InitializedContextServerProtocol {
        let params = types::PromptsGetParams {
            name: prompt.as_ref().to_string(),
            arguments: Some(arguments),
+            meta: None,
        };

        let response: types::PromptsGetResponse = self
@@ -170,6 +170,7 @@ impl InitializedContextServerProtocol {
                name: argument.into(),
                value: value.into(),
            },
+            meta: None,
        };
        let result: types::CompletionCompleteResponse = self
            .inner
@@ -210,6 +211,7 @@ impl InitializedContextServerProtocol {
        let params = types::CallToolParams {
            name: tool.as_ref().to_string(),
            arguments,
+            meta: None,
        };

        let response: types::CallToolResponse = self
--- a/crates/context_servers/src/types.rs
+++ b/crates/context_servers/src/types.rs
@@ -2,8 +2,8 @@ use collections::HashMap;
 use serde::{Deserialize, Serialize};
 use url::Url;

-#[derive(Debug, Serialize)]
-#[serde(rename_all = "camelCase")]
+pub const LATEST_PROTOCOL_VERSION: &str = "2024-11-05";
+
 pub enum RequestType {
    Initialize,
    CallTool,
@@ -18,6 +18,7 @@ pub enum RequestType {
    Ping,
    ListTools,
    ListResourceTemplates,
+    ListRoots,
 }

 impl RequestType {
@@ -36,16 +37,14 @@ impl RequestType {
            RequestType::Ping => "ping",
            RequestType::ListTools => "tools/list",
            RequestType::ListResourceTemplates => "resources/templates/list",
+            RequestType::ListRoots => "roots/list",
        }
    }
 }

 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(untagged)]
-pub enum ProtocolVersion {
-    VersionString(String),
-    VersionNumber(u32),
-}
+#[serde(transparent)]
+pub struct ProtocolVersion(pub String);

 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
@@ -53,6 +52,8 @@ pub struct InitializeParams {
    pub protocol_version: ProtocolVersion,
    pub capabilities: ClientCapabilities,
    pub client_info: Implementation,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Serialize)]
@@ -61,30 +62,40 @@ pub struct CallToolParams {
    pub name: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub arguments: Option<HashMap<String, serde_json::Value>>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesUnsubscribeParams {
    pub uri: Url,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesSubscribeParams {
    pub uri: Url,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesReadParams {
    pub uri: Url,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct LoggingSetLevelParams {
    pub level: LoggingLevel,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Serialize)]
@@ -93,6 +104,8 @@ pub struct PromptsGetParams {
    pub name: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub arguments: Option<HashMap<String, String>>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Serialize)]
@@ -100,6 +113,8 @@ pub struct PromptsGetParams {
 pub struct CompletionCompleteParams {
    pub r#ref: CompletionReference,
    pub argument: CompletionArgument,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Serialize)]
@@ -145,12 +160,16 @@ pub struct InitializeResponse {
    pub protocol_version: ProtocolVersion,
    pub capabilities: ServerCapabilities,
    pub server_info: Implementation,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesReadResponse {
-    pub contents: Vec<ResourceContent>,
+    pub contents: Vec<ResourceContents>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Deserialize)]
@@ -159,29 +178,39 @@ pub struct ResourcesListResponse {
    pub resources: Vec<Resource>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_cursor: Option<String>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
+}
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SamplingMessage {
+    pub role: Role,
+    pub content: MessageContent,
 }

 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct SamplingMessage {
-    pub role: SamplingRole,
-    pub content: SamplingContent,
+pub struct PromptMessage {
+    pub role: Role,
+    pub content: MessageContent,
 }

 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
-pub enum SamplingRole {
+pub enum Role {
    User,
    Assistant,
 }

 #[derive(Debug, Serialize, Deserialize)]
 #[serde(tag = "type")]
-pub enum SamplingContent {
+pub enum MessageContent {
    #[serde(rename = "text")]
    Text { text: String },
    #[serde(rename = "image")]
    Image { data: String, mime_type: String },
+    #[serde(rename = "resource")]
+    Resource { resource: ResourceContents },
 }

 #[derive(Debug, Deserialize)]
@@ -189,7 +218,9 @@ pub enum SamplingContent {
 pub struct PromptsGetResponse {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
-    pub messages: Vec<SamplingMessage>,
+    pub messages: Vec<PromptMessage>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Deserialize)]
@@ -198,12 +229,16 @@ pub struct PromptsListResponse {
    pub prompts: Vec<Prompt>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_cursor: Option<String>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CompletionCompleteResponse {
    pub completion: CompletionResult,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Deserialize)]
@@ -214,6 +249,8 @@ pub struct CompletionResult {
    pub total: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_more: Option<bool>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

 #[derive(Debug, Deserialize, Serialize)]
@@ -243,6 +280,8 @@ pub struct ClientCapabilities {
    pub experimental: Option<HashMap<String, serde_json::Value>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sampling: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub roots: Option<RootsCapabilities>,
 }

 #[derive(Debug, Serialize, Deserialize)]
@@ -283,6 +322,13 @@ pub struct ToolsCapabilities {
    pub list_changed: Option<bool>,
 }

+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RootsCapabilities {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub list_changed: Option<bool>,
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Tool {
@@ -312,14 +358,28 @@ pub struct Resource {

 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct ResourceContent {
+pub struct ResourceContents {
    pub uri: Url,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mime_type: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TextResourceContents {
+    pub uri: Url,
    #[serde(skip_serializing_if = "Option::is_none")]
-    pub text: Option<String>,
+    pub mime_type: Option<String>,
+    pub text: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BlobResourceContents {
+    pub uri: Url,
    #[serde(skip_serializing_if = "Option::is_none")]
-    pub blob: Option<String>,
+    pub mime_type: Option<String>,
+    pub blob: String,
 }

 #[derive(Debug, Serialize, Deserialize)]
@@ -338,8 +398,32 @@ pub struct ResourceTemplate {
 pub enum LoggingLevel {
    Debug,
    Info,
+    Notice,
    Warning,
    Error,
+    Critical,
+    Alert,
+    Emergency,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ModelPreferences {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub hints: Option<Vec<ModelHint>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cost_priority: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub speed_priority: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub intelligence_priority: Option<f64>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ModelHint {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
 }

 #[derive(Debug, Serialize)]
@@ -352,6 +436,7 @@ pub enum NotificationType {
    ResourcesListChanged,
    ToolsListChanged,
    PromptsListChanged,
+    RootsListChanged,
 }

 impl NotificationType {
@@ -364,6 +449,7 @@ impl NotificationType {
            NotificationType::ResourcesListChanged => "notifications/resources/list_changed",
            NotificationType::ToolsListChanged => "notifications/tools/list_changed",
            NotificationType::PromptsListChanged => "notifications/prompts/list_changed",
+            NotificationType::RootsListChanged => "notifications/roots/list_changed",
        }
    }
 }
@@ -373,6 +459,14 @@ impl NotificationType {
 pub enum ClientNotification {
    Initialized,
    Progress(ProgressParams),
+    RootsListChanged,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum ProgressToken {
+    String(String),
+    Number(f64),
 }

 #[derive(Debug, Serialize)]
@@ -382,10 +476,10 @@ pub struct ProgressParams {
    pub progress: f64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub total: Option<f64>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-pub type ProgressToken = String;
-
 pub enum CompletionTotal {
    Exact(u32),
    HasMore,
@@ -410,7 +504,22 @@ pub struct Completion {
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CallToolResponse {
-    pub tool_result: serde_json::Value,
+    pub content: Vec<ToolResponseContent>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub is_error: Option<bool>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum ToolResponseContent {
+    #[serde(rename = "text")]
+    Text { text: String },
+    #[serde(rename = "image")]
+    Image { data: String, mime_type: String },
+    #[serde(rename = "resource")]
+    Resource { resource: ResourceContents },
 }

 #[derive(Debug, Deserialize)]
@@ -419,4 +528,22 @@ pub struct ListToolsResponse {
    pub tools: Vec<Tool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_cursor: Option<String>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ListRootsResponse {
+    pub roots: Vec<Root>,
+    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
+    pub meta: Option<HashMap<String, serde_json::Value>>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Root {
+    pub uri: Url,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
 }
--- a/crates/copilot/Cargo.toml
+++ b/crates/copilot/Cargo.toml
@@ -29,14 +29,14 @@ anyhow.workspace = true
 async-compression.workspace = true
 async-tar.workspace = true
 chrono.workspace = true
-collections.workspace = true
 client.workspace = true
+collections.workspace = true
 command_palette_hooks.workspace = true
-editor.workspace = true
 fs.workspace = true
 futures.workspace = true
 gpui.workspace = true
 http_client.workspace = true
+inline_completion.workspace = true
 language.workspace = true
 lsp.workspace = true
 menu.workspace = true
@@ -44,12 +44,12 @@ node_runtime.workspace = true
 parking_lot.workspace = true
 paths.workspace = true
 project.workspace = true
+schemars = { workspace = true, optional = true }
 serde.workspace = true
 serde_json.workspace = true
-schemars = { workspace = true, optional = true }
-strum.workspace = true
 settings.workspace = true
 smol.workspace = true
+strum.workspace = true
 task.workspace = true
 ui.workspace = true
 util.workspace = true
--- a/crates/copilot/src/copilot.rs
+++ b/crates/copilot/src/copilot.rs
@@ -38,8 +38,8 @@ use std::{
 };
 use util::{fs::remove_matching, maybe, ResultExt};

-pub use copilot_completion_provider::CopilotCompletionProvider;
-pub use sign_in::CopilotCodeVerification;
+pub use crate::copilot_completion_provider::CopilotCompletionProvider;
+pub use crate::sign_in::{initiate_sign_in, CopilotCodeVerification};

 actions!(
    copilot,
@@ -1229,8 +1229,10 @@ mod tests {
            Some(self)
        }

-        fn mtime(&self) -> Option<std::time::SystemTime> {
-            unimplemented!()
+        fn disk_state(&self) -> language::DiskState {
+            language::DiskState::Present {
+                mtime: ::fs::MTime::from_seconds_and_nanos(100, 42),
+            }
        }

        fn path(&self) -> &Arc<Path> {
@@ -1245,10 +1247,6 @@ mod tests {
            unimplemented!()
        }

-        fn is_deleted(&self) -> bool {
-            unimplemented!()
-        }
-
        fn as_any(&self) -> &dyn std::any::Any {
            unimplemented!()
        }
--- a/crates/copilot/src/copilot_chat.rs
+++ b/crates/copilot/src/copilot_chat.rs
@@ -1,13 +1,13 @@
 use std::path::PathBuf;
+use std::sync::Arc;
 use std::sync::OnceLock;
-use std::{sync::Arc, time::Duration};

 use anyhow::{anyhow, Result};
 use chrono::DateTime;
 use fs::Fs;
 use futures::{io::BufReader, stream::BoxStream, AsyncBufReadExt, AsyncReadExt, StreamExt};
 use gpui::{AppContext, AsyncAppContext, Global};
-use http_client::{AsyncBody, HttpClient, HttpRequestExt, Method, Request as HttpRequest};
+use http_client::{AsyncBody, HttpClient, Method, Request as HttpRequest};
 use paths::home_dir;
 use serde::{Deserialize, Serialize};
 use settings::watch_config_file;
@@ -254,7 +254,6 @@ impl CopilotChat {

    pub async fn stream_completion(
        request: Request,
-        low_speed_timeout: Option<Duration>,
        mut cx: AsyncAppContext,
    ) -> Result<BoxStream<'static, Result<ResponseEvent>>> {
        let Some(this) = cx.update(|cx| Self::global(cx)).ok().flatten() else {
@@ -274,8 +273,7 @@ impl CopilotChat {
        let token = match api_token {
            Some(api_token) if api_token.remaining_seconds() > 5 * 60 => api_token.clone(),
            _ => {
-                let token =
-                    request_api_token(&oauth_token, client.clone(), low_speed_timeout).await?;
+                let token = request_api_token(&oauth_token, client.clone()).await?;
                this.update(&mut cx, |this, cx| {
                    this.api_token = Some(token.clone());
                    cx.notify();
@@ -284,25 +282,17 @@ impl CopilotChat {
            }
        };

-        stream_completion(client.clone(), token.api_key, request, low_speed_timeout).await
+        stream_completion(client.clone(), token.api_key, request).await
    }
 }

-async fn request_api_token(
-    oauth_token: &str,
-    client: Arc<dyn HttpClient>,
-    low_speed_timeout: Option<Duration>,
-) -> Result<ApiToken> {
-    let mut request_builder = HttpRequest::builder()
+async fn request_api_token(oauth_token: &str, client: Arc<dyn HttpClient>) -> Result<ApiToken> {
+    let request_builder = HttpRequest::builder()
        .method(Method::GET)
        .uri(COPILOT_CHAT_AUTH_URL)
        .header("Authorization", format!("token {}", oauth_token))
        .header("Accept", "application/json");

-    if let Some(low_speed_timeout) = low_speed_timeout {
-        request_builder = request_builder.read_timeout(low_speed_timeout);
-    }
-
    let request = request_builder.body(AsyncBody::empty())?;

    let mut response = client.send(request).await?;
@@ -340,9 +330,8 @@ async fn stream_completion(
    client: Arc<dyn HttpClient>,
    api_key: String,
    request: Request,
-    low_speed_timeout: Option<Duration>,
 ) -> Result<BoxStream<'static, Result<ResponseEvent>>> {
-    let mut request_builder = HttpRequest::builder()
+    let request_builder = HttpRequest::builder()
        .method(Method::POST)
        .uri(COPILOT_CHAT_COMPLETION_URL)
        .header(
@@ -356,9 +345,6 @@ async fn stream_completion(
        .header("Content-Type", "application/json")
        .header("Copilot-Integration-Id", "vscode-chat");

-    if let Some(low_speed_timeout) = low_speed_timeout {
-        request_builder = request_builder.read_timeout(low_speed_timeout);
-    }
    let is_streaming = request.stream;

    let request = request_builder.body(AsyncBody::from(serde_json::to_string(&request)?))?;
--- a/crates/copilot/src/copilot_completion_provider.rs
+++ b/crates/copilot/src/copilot_completion_provider.rs
@@ -1,8 +1,8 @@
 use crate::{Completion, Copilot};
 use anyhow::Result;
 use client::telemetry::Telemetry;
-use editor::{CompletionProposal, Direction, InlayProposal, InlineCompletionProvider};
 use gpui::{AppContext, EntityId, Model, ModelContext, Task};
+use inline_completion::{CompletionProposal, Direction, InlayProposal, InlineCompletionProvider};
 use language::{
    language_settings::{all_language_settings, AllLanguageSettings},
    Buffer, OffsetRangeExt, ToOffset,
--- a/crates/copilot/src/sign_in.rs
+++ b/crates/copilot/src/sign_in.rs
@@ -5,10 +5,79 @@ use gpui::{
    Styled, Subscription, ViewContext,
 };
 use ui::{prelude::*, Button, Label, Vector, VectorName};
-use workspace::ModalView;
+use util::ResultExt as _;
+use workspace::notifications::NotificationId;
+use workspace::{ModalView, Toast, Workspace};

 const COPILOT_SIGN_UP_URL: &str = "https://github.com/features/copilot";

+struct CopilotStartingToast;
+
+pub fn initiate_sign_in(cx: &mut WindowContext) {
+    let Some(copilot) = Copilot::global(cx) else {
+        return;
+    };
+    let status = copilot.read(cx).status();
+    let Some(workspace) = cx.window_handle().downcast::<Workspace>() else {
+        return;
+    };
+    match status {
+        Status::Starting { task } => {
+            let Some(workspace) = cx.window_handle().downcast::<Workspace>() else {
+                return;
+            };
+
+            let Ok(workspace) = workspace.update(cx, |workspace, cx| {
+                workspace.show_toast(
+                    Toast::new(
+                        NotificationId::unique::<CopilotStartingToast>(),
+                        "Copilot is starting...",
+                    ),
+                    cx,
+                );
+                workspace.weak_handle()
+            }) else {
+                return;
+            };
+
+            cx.spawn(|mut cx| async move {
+                task.await;
+                if let Some(copilot) = cx.update(|cx| Copilot::global(cx)).ok().flatten() {
+                    workspace
+                        .update(&mut cx, |workspace, cx| match copilot.read(cx).status() {
+                            Status::Authorized => workspace.show_toast(
+                                Toast::new(
+                                    NotificationId::unique::<CopilotStartingToast>(),
+                                    "Copilot has started!",
+                                ),
+                                cx,
+                            ),
+                            _ => {
+                                workspace.dismiss_toast(
+                                    &NotificationId::unique::<CopilotStartingToast>(),
+                                    cx,
+                                );
+                                copilot
+                                    .update(cx, |copilot, cx| copilot.sign_in(cx))
+                                    .detach_and_log_err(cx);
+                            }
+                        })
+                        .log_err();
+                }
+            })
+            .detach();
+        }
+        _ => {
+            copilot.update(cx, |this, cx| this.sign_in(cx)).detach();
+            workspace
+                .update(cx, |this, cx| {
+                    this.toggle_modal(cx, |cx| CopilotCodeVerification::new(&copilot, cx));
+                })
+                .ok();
+        }
+    }
+}
+
 pub struct CopilotCodeVerification {
    status: Status,
    connect_clicked: bool,
--- a/crates/diagnostics/src/diagnostics.rs
+++ b/crates/diagnostics/src/diagnostics.rs
@@ -727,6 +727,10 @@ impl Item for ProjectDiagnosticsEditor {
        self.excerpts.read(cx).is_dirty(cx)
    }

+    fn has_deleted_file(&self, cx: &AppContext) -> bool {
+        self.excerpts.read(cx).has_deleted_file(cx)
+    }
+
    fn has_conflict(&self, cx: &AppContext) -> bool {
        self.excerpts.read(cx).has_conflict(cx)
    }
@@ -772,7 +776,7 @@ impl Item for ProjectDiagnosticsEditor {
        }
    }

-    fn breadcrumb_location(&self) -> ToolbarItemLocation {
+    fn breadcrumb_location(&self, _: &AppContext) -> ToolbarItemLocation {
        ToolbarItemLocation::PrimaryLeft
    }

--- a/crates/editor/Cargo.toml
+++ b/crates/editor/Cargo.toml
@@ -42,10 +42,12 @@ emojis.workspace = true
 file_icons.workspace = true
 futures.workspace = true
 fuzzy.workspace = true
+fs.workspace = true
 git.workspace = true
 gpui.workspace = true
 http_client.workspace = true
 indoc.workspace = true
+inline_completion.workspace = true
 itertools.workspace = true
 language.workspace = true
 linkify.workspace = true
--- a/crates/editor/src/actions.rs
+++ b/crates/editor/src/actions.rs
@@ -271,6 +271,8 @@ gpui::actions!(
        Hover,
        Indent,
        JoinLines,
+        KillRingCut,
+        KillRingYank,
        LineDown,
        LineUp,
        MoveDown,
@@ -297,6 +299,7 @@ gpui::actions!(
        OpenExcerptsSplit,
        OpenProposedChangesEditor,
        OpenFile,
+        OpenDocs,
        OpenPermalinkToLine,
        OpenUrl,
        Outdent,
--- a/crates/editor/src/clangd_ext.rs
+++ b/crates/editor/src/clangd_ext.rs
@@ -1,5 +1,3 @@
-use std::path::PathBuf;
-
 use anyhow::Context as _;
 use gpui::{View, ViewContext, WindowContext};
 use language::Language;
@@ -54,9 +52,9 @@ pub fn switch_source_header(
    cx.spawn(|_editor, mut cx| async move {
        let switch_source_header = switch_source_header_task
            .await
-            .with_context(|| format!("Switch source/header LSP request for path \"{}\" failed", source_file))?;
+            .with_context(|| format!("Switch source/header LSP request for path \"{source_file}\" failed"))?;
        if switch_source_header.0.is_empty() {
-            log::info!("Clangd returned an empty string when requesting to switch source/header from \"{}\"", source_file);
+            log::info!("Clangd returned an empty string when requesting to switch source/header from \"{source_file}\"" );
            return Ok(());
        }

@@ -67,14 +65,17 @@ pub fn switch_source_header(
            )
        })?;

+        let path = goto.to_file_path().map_err(|()| {
+            anyhow::anyhow!("URL conversion to file path failed for \"{goto}\"")
+        })?;
+
        workspace
            .update(&mut cx, |workspace, view_cx| {
-                workspace.open_abs_path(PathBuf::from(goto.path()), false, view_cx)
+                workspace.open_abs_path(path, false, view_cx)
            })
            .with_context(|| {
                format!(
-                    "Switch source/header could not open \"{}\" in workspace",
-                    goto.path()
+                    "Switch source/header could not open \"{goto}\" in workspace"
                )
            })?
            .await
--- a/crates/editor/src/debounced_delay.rs
+++ b/crates/editor/src/debounced_delay.rs
@@ -5,6 +5,7 @@ use gpui::{Task, ViewContext};

 use crate::Editor;

+#[derive(Debug)]
 pub struct DebouncedDelay {
    task: Option<Task<()>>,
    cancel_channel: Option<oneshot::Sender<()>>,
--- a/crates/editor/src/display_map.rs
+++ b/crates/editor/src/display_map.rs
@@ -66,7 +66,7 @@ use std::{
 use sum_tree::{Bias, TreeMap};
 use tab_map::{TabMap, TabSnapshot};
 use text::LineIndent;
-use ui::{div, px, IntoElement, ParentElement, SharedString, Styled, WindowContext};
+use ui::{px, SharedString, WindowContext};
 use unicode_segmentation::UnicodeSegmentation;
 use wrap_map::{WrapMap, WrapSnapshot};

@@ -541,11 +541,17 @@ pub struct HighlightStyles {
    pub suggestion: Option<HighlightStyle>,
 }

+#[derive(Clone)]
+pub enum ChunkReplacement {
+    Renderer(ChunkRenderer),
+    Str(SharedString),
+}
+
 pub struct HighlightedChunk<'a> {
    pub text: &'a str,
    pub style: Option<HighlightStyle>,
    pub is_tab: bool,
-    pub renderer: Option<ChunkRenderer>,
+    pub replacement: Option<ChunkReplacement>,
 }

 impl<'a> HighlightedChunk<'a> {
@@ -557,7 +563,7 @@ impl<'a> HighlightedChunk<'a> {
        let mut text = self.text;
        let style = self.style;
        let is_tab = self.is_tab;
-        let renderer = self.renderer;
+        let renderer = self.replacement;
        iter::from_fn(move || {
            let mut prefix_len = 0;
            while let Some(&ch) = chars.peek() {
@@ -573,30 +579,33 @@ impl<'a> HighlightedChunk<'a> {
                        text: prefix,
                        style,
                        is_tab,
-                        renderer: renderer.clone(),
+                        replacement: renderer.clone(),
                    });
                }
                chars.next();
                let (prefix, suffix) = text.split_at(ch.len_utf8());
                text = suffix;
                if let Some(replacement) = replacement(ch) {
-                    let background = editor_style.status.hint_background;
-                    let underline = editor_style.status.hint;
+                    let invisible_highlight = HighlightStyle {
+                        background_color: Some(editor_style.status.hint_background),
+                        underline: Some(UnderlineStyle {
+                            color: Some(editor_style.status.hint),
+                            thickness: px(1.),
+                            wavy: false,
+                        }),
+                        ..Default::default()
+                    };
+                    let invisible_style = if let Some(mut style) = style {
+                        style.highlight(invisible_highlight);
+                        style
+                    } else {
+                        invisible_highlight
+                    };
                    return Some(HighlightedChunk {
                        text: prefix,
-                        style: None,
+                        style: Some(invisible_style),
                        is_tab: false,
-                        renderer: Some(ChunkRenderer {
-                            render: Arc::new(move |_| {
-                                div()
-                                    .child(replacement)
-                                    .bg(background)
-                                    .text_decoration_1()
-                                    .text_decoration_color(underline)
-                                    .into_any_element()
-                            }),
-                            constrain_width: false,
-                        }),
+                        replacement: Some(ChunkReplacement::Str(replacement.into())),
                    });
                } else {
                    let invisible_highlight = HighlightStyle {
@@ -619,7 +628,7 @@ impl<'a> HighlightedChunk<'a> {
                        text: prefix,
                        style: Some(invisible_style),
                        is_tab: false,
-                        renderer: renderer.clone(),
+                        replacement: renderer.clone(),
                    });
                }
            }
@@ -631,7 +640,7 @@ impl<'a> HighlightedChunk<'a> {
                    text: remainder,
                    style,
                    is_tab,
-                    renderer: renderer.clone(),
+                    replacement: renderer.clone(),
                })
            } else {
                None
@@ -895,7 +904,7 @@ impl DisplaySnapshot {
                text: chunk.text,
                style: highlight_style,
                is_tab: chunk.is_tab,
-                renderer: chunk.renderer,
+                replacement: chunk.renderer.map(ChunkReplacement::Renderer),
            }
            .highlight_invisibles(editor_style)
        })
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -28,7 +28,6 @@ mod hover_popover;
 mod hunk_diff;
 mod indent_guides;
 mod inlay_hint_cache;
-mod inline_completion_provider;
 pub mod items;
 mod linked_editing_ranges;
 mod lsp_ext;
@@ -75,7 +74,7 @@ use gpui::{
    div, impl_actions, point, prelude::*, px, relative, size, uniform_list, Action, AnyElement,
    AppContext, AsyncWindowContext, AvailableSpace, BackgroundExecutor, Bounds, ClipboardEntry,
    ClipboardItem, Context, DispatchPhase, ElementId, EventEmitter, FocusHandle, FocusOutEvent,
-    FocusableView, FontId, FontWeight, HighlightStyle, Hsla, InteractiveText, KeyContext,
+    FocusableView, FontId, FontWeight, Global, HighlightStyle, Hsla, InteractiveText, KeyContext,
    ListSizingBehavior, Model, ModelContext, MouseButton, PaintQuad, ParentElement, Pixels, Render,
    ScrollStrategy, SharedString, Size, StrikethroughStyle, Styled, StyledText, Subscription, Task,
    TextStyle, TextStyleRefinement, UTF16Selection, UnderlineStyle, UniformListScrollHandle, View,
@@ -87,7 +86,8 @@ pub(crate) use hunk_diff::HoveredHunk;
 use hunk_diff::{diff_hunk_to_display, ExpandedHunks};
 use indent_guides::ActiveIndentGuidesState;
 use inlay_hint_cache::{InlayHintCache, InlaySplice, InvalidationStrategy};
-pub use inline_completion_provider::*;
+pub use inline_completion::Direction;
+use inline_completion::{InlayProposal, InlineCompletionProvider, InlineCompletionProviderHandle};
 pub use items::MAX_TAB_TITLE_LEN;
 use itertools::Itertools;
 use language::{
@@ -273,12 +273,6 @@ enum DocumentHighlightRead {}
 enum DocumentHighlightWrite {}
 enum InputComposition {}

-#[derive(Copy, Clone, PartialEq, Eq)]
-pub enum Direction {
-    Prev,
-    Next,
-}
-
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum Navigated {
    Yes,
@@ -540,6 +534,15 @@ pub enum IsVimMode {
    No,
 }

+pub trait ActiveLineTrailerProvider {
+    fn render_active_line_trailer(
+        &mut self,
+        style: &EditorStyle,
+        focus_handle: &FocusHandle,
+        cx: &mut WindowContext,
+    ) -> Option<AnyElement>;
+}
+
 /// Zed's primary text input `View`, allowing users to edit a [`MultiBuffer`]
 ///
 /// See the [module level documentation](self) for more information.
@@ -667,6 +670,7 @@ pub struct Editor {
    next_scroll_position: NextScrollCursorCenterTopBottom,
    addons: HashMap<TypeId, Box<dyn Addon>>,
    _scroll_cursor_center_top_bottom_task: Task<()>,
+    active_line_trailer_provider: Option<Box<dyn ActiveLineTrailerProvider>>,
 }

 #[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
@@ -883,6 +887,7 @@ struct AutocloseRegion {
 struct SnippetState {
    ranges: Vec<Vec<Range<Anchor>>>,
    active_index: usize,
+    choices: Vec<Option<Vec<String>>>,
 }

 #[doc(hidden)]
@@ -1000,7 +1005,7 @@ enum ContextMenuOrigin {
    GutterIndicator(DisplayRow),
 }

-#[derive(Clone)]
+#[derive(Clone, Debug)]
 struct CompletionsMenu {
    id: CompletionId,
    sort_completions: bool,
@@ -1011,10 +1016,105 @@ struct CompletionsMenu {
    matches: Arc<[StringMatch]>,
    selected_item: usize,
    scroll_handle: UniformListScrollHandle,
-    selected_completion_documentation_resolve_debounce: Arc<Mutex<DebouncedDelay>>,
+    selected_completion_documentation_resolve_debounce: Option<Arc<Mutex<DebouncedDelay>>>,
 }

 impl CompletionsMenu {
+    fn new(
+        id: CompletionId,
+        sort_completions: bool,
+        initial_position: Anchor,
+        buffer: Model<Buffer>,
+        completions: Box<[Completion]>,
+    ) -> Self {
+        let match_candidates = completions
+            .iter()
+            .enumerate()
+            .map(|(id, completion)| {
+                StringMatchCandidate::new(
+                    id,
+                    completion.label.text[completion.label.filter_range.clone()].into(),
+                )
+            })
+            .collect();
+
+        Self {
+            id,
+            sort_completions,
+            initial_position,
+            buffer,
+            completions: Arc::new(RwLock::new(completions)),
+            match_candidates,
+            matches: Vec::new().into(),
+            selected_item: 0,
+            scroll_handle: UniformListScrollHandle::new(),
+            selected_completion_documentation_resolve_debounce: Some(Arc::new(Mutex::new(
+                DebouncedDelay::new(),
+            ))),
+        }
+    }
+
+    fn new_snippet_choices(
+        id: CompletionId,
+        sort_completions: bool,
+        choices: &Vec<String>,
+        selection: Range<Anchor>,
+        buffer: Model<Buffer>,
+    ) -> Self {
+        let completions = choices
+            .iter()
+            .map(|choice| Completion {
+                old_range: selection.start.text_anchor..selection.end.text_anchor,
+                new_text: choice.to_string(),
+                label: CodeLabel {
+                    text: choice.to_string(),
+                    runs: Default::default(),
+                    filter_range: Default::default(),
+                },
+                server_id: LanguageServerId(usize::MAX),
+                documentation: None,
+                lsp_completion: Default::default(),
+                confirm: None,
+            })
+            .collect();
+
+        let match_candidates = choices
+            .iter()
+            .enumerate()
+            .map(|(id, completion)| StringMatchCandidate::new(id, completion.to_string()))
+            .collect();
+        let matches = choices
+            .iter()
+            .enumerate()
+            .map(|(id, completion)| StringMatch {
+                candidate_id: id,
+                score: 1.,
+                positions: vec![],
+                string: completion.clone(),
+            })
+            .collect();
+        Self {
+            id,
+            sort_completions,
+            initial_position: selection.start,
+            buffer,
+            completions: Arc::new(RwLock::new(completions)),
+            match_candidates,
+            matches,
+            selected_item: 0,
+            scroll_handle: UniformListScrollHandle::new(),
+            selected_completion_documentation_resolve_debounce: Some(Arc::new(Mutex::new(
+                DebouncedDelay::new(),
+            ))),
+        }
+    }
+
+    fn suppress_documentation_resolution(mut self) -> Self {
+        self.selected_completion_documentation_resolve_debounce
+            .take();
+        self
+    }
+
    fn select_first(
        &mut self,
        provider: Option<&dyn CompletionProvider>,
@@ -1115,6 +1215,12 @@ impl CompletionsMenu {
        let Some(provider) = provider else {
            return;
        };
+        let Some(documentation_resolve) = self
+            .selected_completion_documentation_resolve_debounce
+            .as_ref()
+        else {
+            return;
+        };

        let resolve_task = provider.resolve_completions(
            self.buffer.clone(),
@@ -1127,15 +1233,13 @@ impl CompletionsMenu {
            EditorSettings::get_global(cx).completion_documentation_secondary_query_debounce;
        let delay = Duration::from_millis(delay_ms);

-        self.selected_completion_documentation_resolve_debounce
-            .lock()
-            .fire_new(delay, cx, |_, cx| {
-                cx.spawn(move |this, mut cx| async move {
-                    if let Some(true) = resolve_task.await.log_err() {
-                        this.update(&mut cx, |_, cx| cx.notify()).ok();
-                    }
-                })
-            });
+        documentation_resolve.lock().fire_new(delay, cx, |_, cx| {
+            cx.spawn(move |this, mut cx| async move {
+                if let Some(true) = resolve_task.await.log_err() {
+                    this.update(&mut cx, |_, cx| cx.notify()).ok();
+                }
+            })
+        });
    }

    fn visible(&self) -> bool {
@@ -1418,6 +1522,7 @@ impl CompletionsMenu {
    }
 }

+#[derive(Clone)]
 struct AvailableCodeAction {
    excerpt_id: ExcerptId,
    action: CodeAction,
@@ -2104,6 +2209,7 @@ impl Editor {
            addons: HashMap::default(),
            _scroll_cursor_center_top_bottom_task: Task::ready(()),
            text_style_refinement: None,
+            active_line_trailer_provider: None,
        };
        this.tasks_update_task = Some(this.refresh_runnables(cx));
        this._subscriptions.extend(project_subscriptions);
@@ -2392,6 +2498,16 @@ impl Editor {
        self.refresh_inline_completion(false, false, cx);
    }

+    pub fn set_active_line_trailer_provider<T>(
+        &mut self,
+        provider: Option<T>,
+        _cx: &mut ViewContext<Self>,
+    ) where
+        T: ActiveLineTrailerProvider + 'static,
+    {
+        self.active_line_trailer_provider = provider.map(|provider| Box::new(provider) as Box<_>);
+    }
+
    pub fn placeholder_text(&self, _cx: &WindowContext) -> Option<&str> {
        self.placeholder_text.as_deref()
    }
@@ -4386,6 +4502,10 @@ impl Editor {
            return;
        };

+        if !self.snippet_stack.is_empty() && self.context_menu.read().as_ref().is_some() {
+            return;
+        }
+
        let position = self.selections.newest_anchor().head();
        let (buffer, buffer_position) =
            if let Some(output) = self.buffer.read(cx).text_anchor_for_position(position, cx) {
@@ -4431,30 +4551,13 @@ impl Editor {
                })?;
                let completions = completions.await.log_err();
                let menu = if let Some(completions) = completions {
-                    let mut menu = CompletionsMenu {
+                    let mut menu = CompletionsMenu::new(
                        id,
                        sort_completions,
-                        initial_position: position,
-                        match_candidates: completions
-                            .iter()
-                            .enumerate()
-                            .map(|(id, completion)| {
-                                StringMatchCandidate::new(
-                                    id,
-                                    completion.label.text[completion.label.filter_range.clone()]
-                                        .into(),
-                                )
-                            })
-                            .collect(),
-                        buffer: buffer.clone(),
-                        completions: Arc::new(RwLock::new(completions.into())),
-                        matches: Vec::new().into(),
-                        selected_item: 0,
-                        scroll_handle: UniformListScrollHandle::new(),
-                        selected_completion_documentation_resolve_debounce: Arc::new(Mutex::new(
-                            DebouncedDelay::new(),
-                        )),
-                    };
+                        position,
+                        buffer.clone(),
+                        completions.into(),
+                    );
                    menu.filter(query.as_deref(), cx.background_executor().clone())
                        .await;

@@ -4657,7 +4760,11 @@ impl Editor {
        self.transact(cx, |this, cx| {
            if let Some(mut snippet) = snippet {
                snippet.text = text.to_string();
-                for tabstop in snippet.tabstops.iter_mut().flatten() {
+                for tabstop in snippet
+                    .tabstops
+                    .iter_mut()
+                    .flat_map(|tabstop| tabstop.ranges.iter_mut())
+                {
                    tabstop.start -= common_prefix_len as isize;
                    tabstop.end -= common_prefix_len as isize;
                }
@@ -5693,6 +5800,27 @@ impl Editor {
        context_menu
    }

+    fn show_snippet_choices(
+        &mut self,
+        choices: &Vec<String>,
+        selection: Range<Anchor>,
+        cx: &mut ViewContext<Self>,
+    ) {
+        if selection.start.buffer_id.is_none() {
+            return;
+        }
+        let buffer_id = selection.start.buffer_id.unwrap();
+        let buffer = self.buffer().read(cx).buffer(buffer_id);
+        let id = post_inc(&mut self.next_completion_id);
+
+        if let Some(buffer) = buffer {
+            *self.context_menu.write() = Some(ContextMenu::Completions(
+                CompletionsMenu::new_snippet_choices(id, true, choices, selection, buffer)
+                    .suppress_documentation_resolution(),
+            ));
+        }
+    }
+
    pub fn insert_snippet(
        &mut self,
        insertion_ranges: &[Range<usize>],
@@ -5702,6 +5830,7 @@ impl Editor {
        struct Tabstop<T> {
            is_end_tabstop: bool,
            ranges: Vec<Range<T>>,
+            choices: Option<Vec<String>>,
        }

        let tabstops = self.buffer.update(cx, |buffer, cx| {
@@ -5721,10 +5850,11 @@ impl Editor {
                .tabstops
                .iter()
                .map(|tabstop| {
-                    let is_end_tabstop = tabstop.first().map_or(false, |tabstop| {
+                    let is_end_tabstop = tabstop.ranges.first().map_or(false, |tabstop| {
                        tabstop.is_empty() && tabstop.start == snippet.text.len() as isize
                    });
                    let mut tabstop_ranges = tabstop
+                        .ranges
                        .iter()
                        .flat_map(|tabstop_range| {
                            let mut delta = 0_isize;
@@ -5746,6 +5876,7 @@ impl Editor {
                    Tabstop {
                        is_end_tabstop,
                        ranges: tabstop_ranges,
+                        choices: tabstop.choices.clone(),
                    }
                })
                .collect::<Vec<_>>()
@@ -5755,16 +5886,29 @@ impl Editor {
                s.select_ranges(tabstop.ranges.iter().cloned());
            });

+            if let Some(choices) = &tabstop.choices {
+                if let Some(selection) = tabstop.ranges.first() {
+                    self.show_snippet_choices(choices, selection.clone(), cx)
+                }
+            }
+
            // If we're already at the last tabstop and it's at the end of the snippet,
            // we're done, we don't need to keep the state around.
            if !tabstop.is_end_tabstop {
+                let choices = tabstops
+                    .iter()
+                    .map(|tabstop| tabstop.choices.clone())
+                    .collect();
+
                let ranges = tabstops
                    .into_iter()
                    .map(|tabstop| tabstop.ranges)
                    .collect::<Vec<_>>();
+
                self.snippet_stack.push(SnippetState {
                    active_index: 0,
                    ranges,
+                    choices,
                });
            }

@@ -5839,6 +5983,13 @@ impl Editor {
                self.change_selections(Some(Autoscroll::fit()), cx, |s| {
                    s.select_anchor_ranges(current_ranges.iter().cloned())
                });
+
+                if let Some(choices) = &snippet.choices[snippet.active_index] {
+                    if let Some(selection) = current_ranges.first() {
+                        self.show_snippet_choices(&choices, selection.clone(), cx);
+                    }
+                }
+
                // If snippet state is not at the last tabstop, push it back on the stack
                if snippet.active_index + 1 < snippet.ranges.len() {
                    self.snippet_stack.push(snippet);
@@ -7213,7 +7364,7 @@ impl Editor {
            .update(cx, |buffer, cx| buffer.edit(edits, None, cx));
    }

-    pub fn cut(&mut self, _: &Cut, cx: &mut ViewContext<Self>) {
+    pub fn cut_common(&mut self, cx: &mut ViewContext<Self>) -> ClipboardItem {
        let mut text = String::new();
        let buffer = self.buffer.read(cx).snapshot(cx);
        let mut selections = self.selections.all::<Point>(cx);
@@ -7257,11 +7408,38 @@ impl Editor {
                s.select(selections);
            });
            this.insert("", cx);
-            cx.write_to_clipboard(ClipboardItem::new_string_with_json_metadata(
-                text,
-                clipboard_selections,
-            ));
        });
+        ClipboardItem::new_string_with_json_metadata(text, clipboard_selections)
+    }
+
+    pub fn cut(&mut self, _: &Cut, cx: &mut ViewContext<Self>) {
+        let item = self.cut_common(cx);
+        cx.write_to_clipboard(item);
+    }
+
+    pub fn kill_ring_cut(&mut self, _: &KillRingCut, cx: &mut ViewContext<Self>) {
+        self.change_selections(None, cx, |s| {
+            s.move_with(|snapshot, sel| {
+                if sel.is_empty() {
+                    sel.end = DisplayPoint::new(sel.end.row(), snapshot.line_len(sel.end.row()))
+                }
+            });
+        });
+        let item = self.cut_common(cx);
+        cx.set_global(KillRing(item))
+    }
+
+    pub fn kill_ring_yank(&mut self, _: &KillRingYank, cx: &mut ViewContext<Self>) {
+        let (text, metadata) = if let Some(KillRing(item)) = cx.try_global() {
+            if let Some(ClipboardEntry::String(kill_ring)) = item.entries().first() {
+                (kill_ring.text().to_string(), kill_ring.metadata_json())
+            } else {
+                return;
+            }
+        } else {
+            return;
+        };
+        self.do_paste(&text, metadata, false, cx);
    }

    pub fn copy(&mut self, _: &Copy, cx: &mut ViewContext<Self>) {
@@ -11713,6 +11891,29 @@ impl Editor {
            && self.has_blame_entries(cx)
    }

+    pub fn render_active_line_trailer(
+        &mut self,
+        style: &EditorStyle,
+        cx: &mut WindowContext,
+    ) -> Option<AnyElement> {
+        let selection = self.selections.newest::<Point>(cx);
+        if !selection.is_empty() {
+            return None;
+        };
+
+        let snapshot = self.buffer.read(cx).snapshot(cx);
+        let buffer_row = MultiBufferRow(selection.head().row);
+
+        if snapshot.line_len(buffer_row) != 0 || self.has_active_inline_completion(cx) {
+            return None;
+        }
+
+        let focus_handle = self.focus_handle.clone();
+        self.active_line_trailer_provider
+            .as_mut()?
+            .render_active_line_trailer(style, &focus_handle, cx)
+    }
+
    fn has_blame_entries(&self, cx: &mut WindowContext) -> bool {
        self.blame()
            .map_or(false, |blame| blame.read(cx).has_generated_entries())
@@ -13610,7 +13811,9 @@ impl CodeActionProvider for Model<Project> {
        range: Range<text::Anchor>,
        cx: &mut WindowContext,
    ) -> Task<Result<Vec<CodeAction>>> {
-        self.update(cx, |project, cx| project.code_actions(buffer, range, cx))
+        self.update(cx, |project, cx| {
+            project.code_actions(buffer, range, None, cx)
+        })
    }

    fn apply_code_action(
@@ -14254,15 +14457,16 @@ impl ViewInputHandler for Editor {
    fn text_for_range(
        &mut self,
        range_utf16: Range<usize>,
+        adjusted_range: &mut Option<Range<usize>>,
        cx: &mut ViewContext<Self>,
    ) -> Option<String> {
-        Some(
-            self.buffer
-                .read(cx)
-                .read(cx)
-                .text_for_range(OffsetUtf16(range_utf16.start)..OffsetUtf16(range_utf16.end))
-                .collect(),
-        )
+        let snapshot = self.buffer.read(cx).read(cx);
+        let start = snapshot.clip_offset_utf16(OffsetUtf16(range_utf16.start), Bias::Left);
+        let end = snapshot.clip_offset_utf16(OffsetUtf16(range_utf16.end), Bias::Right);
+        if (start.0..end.0) != range_utf16 {
+            adjusted_range.replace(start.0..end.0);
+        }
+        Some(snapshot.text_for_range(start..end).collect())
    }

    fn selected_text_range(
@@ -14970,4 +15174,7 @@ fn check_multiline_range(buffer: &Buffer, range: Range<usize>) -> Range<usize> {
    }
 }

+pub struct KillRing(ClipboardItem);
+impl Global for KillRing {}
+
 const UPDATE_DEBOUNCE: Duration = Duration::from_millis(50);
--- a/crates/editor/src/editor_settings.rs
+++ b/crates/editor/src/editor_settings.rs
@@ -279,7 +279,7 @@ pub struct EditorSettingsContent {

    /// Whether to show the signature help pop-up after completions or bracket pairs inserted.
    ///
-    /// Default: true
+    /// Default: false
    pub show_signature_help_after_edits: Option<bool>,

    /// Jupyter REPL settings.
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -1398,6 +1398,15 @@ fn test_move_cursor_different_line_lengths(cx: &mut TestAppContext) {
        view.change_selections(None, cx, |s| {
            s.select_display_ranges([empty_range(0, "ⓐⓑⓒⓓⓔ".len())]);
        });
+
+        // moving above start of document should move selection to start of document,
+        // but the next move down should still be at the original goal_x
+        view.move_up(&MoveUp, cx);
+        assert_eq!(
+            view.selections.display_ranges(cx),
+            &[empty_range(0, "".len())]
+        );
+
        view.move_down(&MoveDown, cx);
        assert_eq!(
            view.selections.display_ranges(cx),
@@ -1422,6 +1431,25 @@ fn test_move_cursor_different_line_lengths(cx: &mut TestAppContext) {
            &[empty_range(4, "ⓐⓑⓒⓓⓔ".len())]
        );

+        // moving past end of document should not change goal_x
+        view.move_down(&MoveDown, cx);
+        assert_eq!(
+            view.selections.display_ranges(cx),
+            &[empty_range(5, "".len())]
+        );
+
+        view.move_down(&MoveDown, cx);
+        assert_eq!(
+            view.selections.display_ranges(cx),
+            &[empty_range(5, "".len())]
+        );
+
+        view.move_up(&MoveUp, cx);
+        assert_eq!(
+            view.selections.display_ranges(cx),
+            &[empty_range(4, "ⓐⓑⓒⓓⓔ".len())]
+        );
+
        view.move_up(&MoveUp, cx);
        assert_eq!(
            view.selections.display_ranges(cx),
@@ -6551,6 +6579,45 @@ async fn test_auto_replace_emoji_shortcode(cx: &mut gpui::TestAppContext) {
    });
 }

+#[gpui::test]
+async fn test_snippet_placeholder_choices(cx: &mut gpui::TestAppContext) {
+    init_test(cx, |_| {});
+
+    let (text, insertion_ranges) = marked_text_ranges(
+        indoc! {"
+            ˇ
+        "},
+        false,
+    );
+
+    let buffer = cx.update(|cx| MultiBuffer::build_simple(&text, cx));
+    let (editor, cx) = cx.add_window_view(|cx| build_editor(buffer, cx));
+
+    _ = editor.update(cx, |editor, cx| {
+        let snippet = Snippet::parse("type ${1|,i32,u32|} = $2").unwrap();
+
+        editor
+            .insert_snippet(&insertion_ranges, snippet, cx)
+            .unwrap();
+
+        fn assert(editor: &mut Editor, cx: &mut ViewContext<Editor>, marked_text: &str) {
+            let (expected_text, selection_ranges) = marked_text_ranges(marked_text, false);
+            assert_eq!(editor.text(cx), expected_text);
+            assert_eq!(editor.selections.ranges::<usize>(cx), selection_ranges);
+        }
+
+        assert(
+            editor,
+            cx,
+            indoc! {"
+            type «» =•
+            "},
+        );
+
+        assert!(editor.context_menu_visible(), "There should be a matches");
+    });
+}
+
 #[gpui::test]
 async fn test_snippets(cx: &mut gpui::TestAppContext) {
    init_test(cx, |_| {});
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -16,8 +16,8 @@ use crate::{
    items::BufferSearchHighlights,
    mouse_context_menu::{self, MenuPosition, MouseContextMenu},
    scroll::scroll_amount::ScrollAmount,
-    BlockId, CodeActionsMenu, CursorShape, CustomBlockId, DisplayPoint, DisplayRow,
-    DocumentHighlightRead, DocumentHighlightWrite, Editor, EditorMode, EditorSettings,
+    BlockId, ChunkReplacement, CodeActionsMenu, CursorShape, CustomBlockId, DisplayPoint,
+    DisplayRow, DocumentHighlightRead, DocumentHighlightWrite, Editor, EditorMode, EditorSettings,
    EditorSnapshot, EditorStyle, ExpandExcerpts, FocusedBlock, GutterDimensions, HalfPageDown,
    HalfPageUp, HandleInput, HoveredCursor, HoveredHunk, JumpData, LineDown, LineUp, OpenExcerpts,
    PageDown, PageUp, Point, RowExt, RowRangeExt, SelectPhase, Selection, SoftWrap, ToPoint,
@@ -34,8 +34,8 @@ use gpui::{
    FontId, GlobalElementId, Hitbox, Hsla, InteractiveElement, IntoElement, Length,
    ModifiersChangedEvent, MouseButton, MouseDownEvent, MouseMoveEvent, MouseUpEvent, PaintQuad,
    ParentElement, Pixels, ScrollDelta, ScrollWheelEvent, ShapedLine, SharedString, Size,
-    StatefulInteractiveElement, Style, Styled, TextRun, TextStyle, TextStyleRefinement, View,
-    ViewContext, WeakView, WindowContext,
+    StatefulInteractiveElement, Style, Styled, TextRun, TextStyleRefinement, View, ViewContext,
+    WeakView, WindowContext,
 };
 use gpui::{ClickEvent, Subscription};
 use itertools::Itertools;
@@ -217,6 +217,8 @@ impl EditorElement {
        register_action(view, cx, Editor::transpose);
        register_action(view, cx, Editor::rewrap);
        register_action(view, cx, Editor::cut);
+        register_action(view, cx, Editor::kill_ring_cut);
+        register_action(view, cx, Editor::kill_ring_yank);
        register_action(view, cx, Editor::copy);
        register_action(view, cx, Editor::paste);
        register_action(view, cx, Editor::undo);
@@ -1412,7 +1414,7 @@ impl EditorElement {
    }

    #[allow(clippy::too_many_arguments)]
-    fn layout_inline_blame(
+    fn layout_active_line_trailer(
        &self,
        display_row: DisplayRow,
        display_snapshot: &DisplaySnapshot,
@@ -1424,61 +1426,71 @@ impl EditorElement {
        line_height: Pixels,
        cx: &mut WindowContext,
    ) -> Option<AnyElement> {
-        if !self
+        let render_inline_blame = self
            .editor
-            .update(cx, |editor, cx| editor.render_git_blame_inline(cx))
-        {
-            return None;
-        }
+            .update(cx, |editor, cx| editor.render_git_blame_inline(cx));
+        if render_inline_blame {
+            let workspace = self
+                .editor
+                .read(cx)
+                .workspace
+                .as_ref()
+                .map(|(w, _)| w.clone());

-        let workspace = self
-            .editor
-            .read(cx)
-            .workspace
-            .as_ref()
-            .map(|(w, _)| w.clone());
+            let display_point = DisplayPoint::new(display_row, 0);
+            let buffer_row = MultiBufferRow(display_point.to_point(display_snapshot).row);

-        let display_point = DisplayPoint::new(display_row, 0);
-        let buffer_row = MultiBufferRow(display_point.to_point(display_snapshot).row);
+            let blame = self.editor.read(cx).blame.clone()?;
+            let blame_entry = blame
+                .update(cx, |blame, cx| {
+                    blame.blame_for_rows([Some(buffer_row)], cx).next()
+                })
+                .flatten()?;

-        let blame = self.editor.read(cx).blame.clone()?;
-        let blame_entry = blame
-            .update(cx, |blame, cx| {
-                blame.blame_for_rows([Some(buffer_row)], cx).next()
-            })
-            .flatten()?;
+            let mut element =
+                render_inline_blame_entry(&blame, blame_entry, &self.style, workspace, cx);

-        let mut element =
-            render_inline_blame_entry(&blame, blame_entry, &self.style, workspace, cx);
+            let start_y = content_origin.y
+                + line_height * (display_row.as_f32() - scroll_pixel_position.y / line_height);

-        let start_y = content_origin.y
-            + line_height * (display_row.as_f32() - scroll_pixel_position.y / line_height);
+            let start_x = {
+                const INLINE_BLAME_PADDING_EM_WIDTHS: f32 = 6.;

-        let start_x = {
-            const INLINE_BLAME_PADDING_EM_WIDTHS: f32 = 6.;
+                let line_end = if let Some(crease_trailer) = crease_trailer {
+                    crease_trailer.bounds.right()
+                } else {
+                    content_origin.x - scroll_pixel_position.x + line_layout.width
+                };
+                let padded_line_end = line_end + em_width * INLINE_BLAME_PADDING_EM_WIDTHS;

-            let line_end = if let Some(crease_trailer) = crease_trailer {
-                crease_trailer.bounds.right()
-            } else {
-                content_origin.x - scroll_pixel_position.x + line_layout.width
+                let min_column_in_pixels = ProjectSettings::get_global(cx)
+                    .git
+                    .inline_blame
+                    .and_then(|settings| settings.min_column)
+                    .map(|col| self.column_pixels(col as usize, cx))
+                    .unwrap_or(px(0.));
+                let min_start = content_origin.x - scroll_pixel_position.x + min_column_in_pixels;
+
+                cmp::max(padded_line_end, min_start)
            };
-            let padded_line_end = line_end + em_width * INLINE_BLAME_PADDING_EM_WIDTHS;

-            let min_column_in_pixels = ProjectSettings::get_global(cx)
-                .git
-                .inline_blame
-                .and_then(|settings| settings.min_column)
-                .map(|col| self.column_pixels(col as usize, cx))
-                .unwrap_or(px(0.));
-            let min_start = content_origin.x - scroll_pixel_position.x + min_column_in_pixels;
+            let absolute_offset = point(start_x, start_y);
+            element.prepaint_as_root(absolute_offset, AvailableSpace::min_size(), cx);

-            cmp::max(padded_line_end, min_start)
-        };
+            Some(element)
+        } else if let Some(mut element) = self.editor.update(cx, |editor, cx| {
+            editor.render_active_line_trailer(&self.style, cx)
+        }) {
+            let start_y = content_origin.y
+                + line_height * (display_row.as_f32() - scroll_pixel_position.y / line_height);
+            let start_x = content_origin.x - scroll_pixel_position.x + em_width;
+            let absolute_offset = point(start_x, start_y);
+            element.prepaint_as_root(absolute_offset, AvailableSpace::min_size(), cx);

-        let absolute_offset = point(start_x, start_y);
-        element.prepaint_as_root(absolute_offset, AvailableSpace::min_size(), cx);
-
-        Some(element)
+            Some(element)
+        } else {
+            None
+        }
    }

    #[allow(clippy::too_many_arguments)]
@@ -2019,7 +2031,7 @@ impl EditorElement {
            let chunks = snapshot.highlighted_chunks(rows.clone(), true, style);
            LineWithInvisibles::from_chunks(
                chunks,
-                &style.text,
+                &style,
                MAX_LINE_LEN,
                rows.len(),
                snapshot.mode,
@@ -3454,7 +3466,7 @@ impl EditorElement {
                self.paint_lines(&invisible_display_ranges, layout, cx);
                self.paint_redactions(layout, cx);
                self.paint_cursors(layout, cx);
-                self.paint_inline_blame(layout, cx);
+                self.paint_active_line_trailer(layout, cx);
                cx.with_element_namespace("crease_trailers", |cx| {
                    for trailer in layout.crease_trailers.iter_mut().flatten() {
                        trailer.element.paint(cx);
@@ -3936,10 +3948,10 @@ impl EditorElement {
        }
    }

-    fn paint_inline_blame(&mut self, layout: &mut EditorLayout, cx: &mut WindowContext) {
-        if let Some(mut inline_blame) = layout.inline_blame.take() {
+    fn paint_active_line_trailer(&mut self, layout: &mut EditorLayout, cx: &mut WindowContext) {
+        if let Some(mut element) = layout.active_line_trailer.take() {
            cx.paint_layer(layout.text_hitbox.bounds, |cx| {
-                inline_blame.paint(cx);
+                element.paint(cx);
            })
        }
    }
@@ -4372,7 +4384,7 @@ impl LineWithInvisibles {
    #[allow(clippy::too_many_arguments)]
    fn from_chunks<'a>(
        chunks: impl Iterator<Item = HighlightedChunk<'a>>,
-        text_style: &TextStyle,
+        editor_style: &EditorStyle,
        max_line_len: usize,
        max_line_count: usize,
        editor_mode: EditorMode,
@@ -4380,6 +4392,7 @@ impl LineWithInvisibles {
        is_row_soft_wrapped: impl Copy + Fn(usize) -> bool,
        cx: &mut WindowContext,
    ) -> Vec<Self> {
+        let text_style = &editor_style.text;
        let mut layouts = Vec::with_capacity(max_line_count);
        let mut fragments: SmallVec<[LineFragment; 1]> = SmallVec::new();
        let mut line = String::new();
@@ -4398,9 +4411,9 @@ impl LineWithInvisibles {
            text: "\n",
            style: None,
            is_tab: false,
-            renderer: None,
+            replacement: None,
        }]) {
-            if let Some(renderer) = highlighted_chunk.renderer {
+            if let Some(replacement) = highlighted_chunk.replacement {
                if !line.is_empty() {
                    let shaped_line = cx
                        .text_system()
@@ -4413,42 +4426,71 @@ impl LineWithInvisibles {
                    styles.clear();
                }

-                let available_width = if renderer.constrain_width {
-                    let chunk = if highlighted_chunk.text == ellipsis.as_ref() {
-                        ellipsis.clone()
-                    } else {
-                        SharedString::from(Arc::from(highlighted_chunk.text))
-                    };
-                    let shaped_line = cx
-                        .text_system()
-                        .shape_line(
-                            chunk,
-                            font_size,
-                            &[text_style.to_run(highlighted_chunk.text.len())],
-                        )
-                        .unwrap();
-                    AvailableSpace::Definite(shaped_line.width)
-                } else {
-                    AvailableSpace::MinContent
-                };
+                match replacement {
+                    ChunkReplacement::Renderer(renderer) => {
+                        let available_width = if renderer.constrain_width {
+                            let chunk = if highlighted_chunk.text == ellipsis.as_ref() {
+                                ellipsis.clone()
+                            } else {
+                                SharedString::from(Arc::from(highlighted_chunk.text))
+                            };
+                            let shaped_line = cx
+                                .text_system()
+                                .shape_line(
+                                    chunk,
+                                    font_size,
+                                    &[text_style.to_run(highlighted_chunk.text.len())],
+                                )
+                                .unwrap();
+                            AvailableSpace::Definite(shaped_line.width)
+                        } else {
+                            AvailableSpace::MinContent
+                        };

-                let mut element = (renderer.render)(&mut ChunkRendererContext {
-                    context: cx,
-                    max_width: text_width,
-                });
-                let line_height = text_style.line_height_in_pixels(cx.rem_size());
-                let size = element.layout_as_root(
-                    size(available_width, AvailableSpace::Definite(line_height)),
-                    cx,
-                );
+                        let mut element = (renderer.render)(&mut ChunkRendererContext {
+                            context: cx,
+                            max_width: text_width,
+                        });
+                        let line_height = text_style.line_height_in_pixels(cx.rem_size());
+                        let size = element.layout_as_root(
+                            size(available_width, AvailableSpace::Definite(line_height)),
+                            cx,
+                        );

-                width += size.width;
-                len += highlighted_chunk.text.len();
-                fragments.push(LineFragment::Element {
-                    element: Some(element),
-                    size,
-                    len: highlighted_chunk.text.len(),
-                });
+                        width += size.width;
+                        len += highlighted_chunk.text.len();
+                        fragments.push(LineFragment::Element {
+                            element: Some(element),
+                            size,
+                            len: highlighted_chunk.text.len(),
+                        });
+                    }
+                    ChunkReplacement::Str(x) => {
+                        let text_style = if let Some(style) = highlighted_chunk.style {
+                            Cow::Owned(text_style.clone().highlight(style))
+                        } else {
+                            Cow::Borrowed(text_style)
+                        };
+
+                        let run = TextRun {
+                            len: x.len(),
+                            font: text_style.font(),
+                            color: text_style.color,
+                            background_color: text_style.background_color,
+                            underline: text_style.underline,
+                            strikethrough: text_style.strikethrough,
+                        };
+                        let line_layout = cx
+                            .text_system()
+                            .shape_line(x, font_size, &[run])
+                            .unwrap()
+                            .with_len(highlighted_chunk.text.len());
+
+                        width += line_layout.width;
+                        len += highlighted_chunk.text.len();
+                        fragments.push(LineFragment::Text(line_layout))
+                    }
+                }
            } else {
                for (ix, mut line_chunk) in highlighted_chunk.text.split('\n').enumerate() {
                    if ix > 0 {
@@ -5301,14 +5343,14 @@ impl Element for EditorElement {
                        )
                    });

-                    let mut inline_blame = None;
+                    let mut active_line_trailer = None;
                    if let Some(newest_selection_head) = newest_selection_head {
                        let display_row = newest_selection_head.row();
                        if (start_row..end_row).contains(&display_row) {
                            let line_ix = display_row.minus(start_row) as usize;
                            let line_layout = &line_layouts[line_ix];
                            let crease_trailer_layout = crease_trailers[line_ix].as_ref();
-                            inline_blame = self.layout_inline_blame(
+                            active_line_trailer = self.layout_active_line_trailer(
                                display_row,
                                &snapshot.display_snapshot,
                                line_layout,
@@ -5627,7 +5669,7 @@ impl Element for EditorElement {
                        line_elements,
                        line_numbers,
                        blamed_display_rows,
-                        inline_blame,
+                        active_line_trailer,
                        blocks,
                        cursors,
                        visible_cursors,
@@ -5764,7 +5806,7 @@ pub struct EditorLayout {
    line_numbers: Vec<Option<ShapedLine>>,
    display_hunks: Vec<(DisplayDiffHunk, Option<Hitbox>)>,
    blamed_display_rows: Option<Vec<AnyElement>>,
-    inline_blame: Option<AnyElement>,
+    active_line_trailer: Option<AnyElement>,
    blocks: Vec<BlockLayout>,
    highlighted_ranges: Vec<(Range<DisplayPoint>, Hsla)>,
    highlighted_gutter_ranges: Vec<(Range<DisplayPoint>, Hsla)>,
@@ -5992,7 +6034,7 @@ fn layout_line(
    let chunks = snapshot.highlighted_chunks(row..row + DisplayRow(1), true, style);
    LineWithInvisibles::from_chunks(
        chunks,
-        &style.text,
+        &style,
        MAX_LINE_LEN,
        1,
        snapshot.mode,
--- a/crates/editor/src/items.rs
+++ b/crates/editor/src/items.rs
@@ -16,7 +16,8 @@ use gpui::{
    VisualContext, WeakView, WindowContext,
 };
 use language::{
-    proto::serialize_anchor as serialize_text_anchor, Bias, Buffer, CharKind, Point, SelectionGoal,
+    proto::serialize_anchor as serialize_text_anchor, Bias, Buffer, CharKind, DiskState, Point,
+    SelectionGoal,
 };
 use lsp::DiagnosticSeverity;
 use multi_buffer::AnchorRangeExt;
@@ -635,12 +636,21 @@ impl Item for Editor {
            Some(util::truncate_and_trailoff(description, MAX_TAB_TITLE_LEN))
        });

+        // Whether the file was saved in the past but is now deleted.
+        let was_deleted: bool = self
+            .buffer()
+            .read(cx)
+            .as_singleton()
+            .and_then(|buffer| buffer.read(cx).file())
+            .map_or(false, |file| file.disk_state() == DiskState::Deleted);
+
        h_flex()
            .gap_2()
            .child(
                Label::new(self.title(cx).to_string())
                    .color(label_color)
-                    .italic(params.preview),
+                    .italic(params.preview)
+                    .strikethrough(was_deleted),
            )
            .when_some(description, |this, description| {
                this.child(
@@ -700,6 +710,10 @@ impl Item for Editor {
        self.buffer().read(cx).read(cx).is_dirty()
    }

+    fn has_deleted_file(&self, cx: &AppContext) -> bool {
+        self.buffer().read(cx).read(cx).has_deleted_file()
+    }
+
    fn has_conflict(&self, cx: &AppContext) -> bool {
        self.buffer().read(cx).read(cx).has_conflict()
    }
@@ -827,7 +841,7 @@ impl Item for Editor {
        self.pixel_position_of_newest_cursor
    }

-    fn breadcrumb_location(&self) -> ToolbarItemLocation {
+    fn breadcrumb_location(&self, _: &AppContext) -> ToolbarItemLocation {
        if self.show_breadcrumbs {
            ToolbarItemLocation::PrimaryLeft
        } else {
@@ -1604,15 +1618,14 @@ fn path_for_file<'a>(
 #[cfg(test)]
 mod tests {
    use crate::editor_tests::init_test;
+    use fs::Fs;

    use super::*;
+    use fs::MTime;
    use gpui::{AppContext, VisualTestContext};
    use language::{LanguageMatcher, TestFile};
    use project::FakeFs;
-    use std::{
-        path::{Path, PathBuf},
-        time::SystemTime,
-    };
+    use std::path::{Path, PathBuf};

    #[gpui::test]
    fn test_path_for_file(cx: &mut AppContext) {
@@ -1665,9 +1678,7 @@ mod tests {
    async fn test_deserialize(cx: &mut gpui::TestAppContext) {
        init_test(cx, |_| {});

-        let now = SystemTime::now();
        let fs = FakeFs::new(cx.executor());
-        fs.set_next_mtime(now);
        fs.insert_file("/file.rs", Default::default()).await;

        // Test case 1: Deserialize with path and contents
@@ -1676,12 +1687,18 @@ mod tests {
            let (workspace, cx) = cx.add_window_view(|cx| Workspace::test_new(project.clone(), cx));
            let workspace_id = workspace::WORKSPACE_DB.next_id().await.unwrap();
            let item_id = 1234 as ItemId;
+            let mtime = fs
+                .metadata(Path::new("/file.rs"))
+                .await
+                .unwrap()
+                .unwrap()
+                .mtime;

            let serialized_editor = SerializedEditor {
                abs_path: Some(PathBuf::from("/file.rs")),
                contents: Some("fn main() {}".to_string()),
                language: Some("Rust".to_string()),
-                mtime: Some(now),
+                mtime: Some(mtime),
            };

            DB.save_serialized_editor(item_id, workspace_id, serialized_editor.clone())
@@ -1778,9 +1795,7 @@ mod tests {
            let workspace_id = workspace::WORKSPACE_DB.next_id().await.unwrap();

            let item_id = 9345 as ItemId;
-            let old_mtime = now
-                .checked_sub(std::time::Duration::from_secs(60 * 60 * 24))
-                .unwrap();
+            let old_mtime = MTime::from_seconds_and_nanos(0, 50);
            let serialized_editor = SerializedEditor {
                abs_path: Some(PathBuf::from("/file.rs")),
                contents: Some("fn main() {}".to_string()),
--- a/crates/editor/src/movement.rs
+++ b/crates/editor/src/movement.rs
@@ -3,7 +3,7 @@

 use super::{Bias, DisplayPoint, DisplaySnapshot, SelectionGoal, ToDisplayPoint};
 use crate::{scroll::ScrollAnchor, CharKind, DisplayRow, EditorStyle, RowExt, ToOffset, ToPoint};
-use gpui::{px, Pixels, WindowTextSystem};
+use gpui::{Pixels, WindowTextSystem};
 use language::Point;
 use multi_buffer::{MultiBufferRow, MultiBufferSnapshot};
 use serde::Deserialize;
@@ -120,7 +120,7 @@ pub(crate) fn up_by_rows(
    preserve_column_at_start: bool,
    text_layout_details: &TextLayoutDetails,
 ) -> (DisplayPoint, SelectionGoal) {
-    let mut goal_x = match goal {
+    let goal_x = match goal {
        SelectionGoal::HorizontalPosition(x) => x.into(),
        SelectionGoal::WrappedHorizontalPosition((_, x)) => x.into(),
        SelectionGoal::HorizontalRange { end, .. } => end.into(),
@@ -138,7 +138,6 @@ pub(crate) fn up_by_rows(
        return (start, goal);
    } else {
        point = DisplayPoint::new(DisplayRow(0), 0);
-        goal_x = px(0.);
    }

    let mut clipped_point = map.clip_point(point, Bias::Left);
@@ -159,7 +158,7 @@ pub(crate) fn down_by_rows(
    preserve_column_at_end: bool,
    text_layout_details: &TextLayoutDetails,
 ) -> (DisplayPoint, SelectionGoal) {
-    let mut goal_x = match goal {
+    let goal_x = match goal {
        SelectionGoal::HorizontalPosition(x) => x.into(),
        SelectionGoal::WrappedHorizontalPosition((_, x)) => x.into(),
        SelectionGoal::HorizontalRange { end, .. } => end.into(),
@@ -174,7 +173,6 @@ pub(crate) fn down_by_rows(
        return (start, goal);
    } else {
        point = map.max_point();
-        goal_x = map.x_for_display_point(point, text_layout_details)
    }

    let mut clipped_point = map.clip_point(point, Bias::Right);
@@ -610,7 +608,7 @@ mod tests {
        test::{editor_test_context::EditorTestContext, marked_display_snapshot},
        Buffer, DisplayMap, DisplayRow, ExcerptRange, FoldPlaceholder, InlayId, MultiBuffer,
    };
-    use gpui::{font, Context as _};
+    use gpui::{font, px, Context as _};
    use language::Capability;
    use project::Project;
    use settings::SettingsStore;
@@ -977,7 +975,7 @@ mod tests {
                ),
                (
                    DisplayPoint::new(DisplayRow(2), 0),
-                    SelectionGoal::HorizontalPosition(0.0)
+                    SelectionGoal::HorizontalPosition(col_2_x.0),
                ),
            );
            assert_eq!(
@@ -990,7 +988,7 @@ mod tests {
                ),
                (
                    DisplayPoint::new(DisplayRow(2), 0),
-                    SelectionGoal::HorizontalPosition(0.0)
+                    SelectionGoal::HorizontalPosition(0.0),
                ),
            );

@@ -1059,7 +1057,7 @@ mod tests {
            let max_point_x = snapshot
                .x_for_display_point(DisplayPoint::new(DisplayRow(7), 2), &text_layout_details);

-            // Can't move down off the end
+            // Can't move down off the end, and attempting to do so leaves the selection goal unchanged
            assert_eq!(
                down(
                    &snapshot,
@@ -1070,7 +1068,7 @@ mod tests {
                ),
                (
                    DisplayPoint::new(DisplayRow(7), 2),
-                    SelectionGoal::HorizontalPosition(max_point_x.0)
+                    SelectionGoal::HorizontalPosition(0.0)
                ),
            );
            assert_eq!(
--- a/crates/editor/src/persistence.rs
+++ b/crates/editor/src/persistence.rs
@@ -1,8 +1,8 @@
 use anyhow::Result;
 use db::sqlez::bindable::{Bind, Column, StaticColumnCount};
 use db::sqlez::statement::Statement;
+use fs::MTime;
 use std::path::PathBuf;
-use std::time::{Duration, SystemTime, UNIX_EPOCH};

 use db::sqlez_macros::sql;
 use db::{define_connection, query};
@@ -14,7 +14,7 @@ pub(crate) struct SerializedEditor {
    pub(crate) abs_path: Option<PathBuf>,
    pub(crate) contents: Option<String>,
    pub(crate) language: Option<String>,
-    pub(crate) mtime: Option<SystemTime>,
+    pub(crate) mtime: Option<MTime>,
 }

 impl StaticColumnCount for SerializedEditor {
@@ -29,16 +29,13 @@ impl Bind for SerializedEditor {
        let start_index = statement.bind(&self.contents, start_index)?;
        let start_index = statement.bind(&self.language, start_index)?;

-        let mtime = self.mtime.and_then(|mtime| {
-            mtime
-                .duration_since(UNIX_EPOCH)
-                .ok()
-                .map(|duration| (duration.as_secs() as i64, duration.subsec_nanos() as i32))
-        });
-        let start_index = match mtime {
+        let start_index = match self
+            .mtime
+            .and_then(|mtime| mtime.to_seconds_and_nanos_for_persistence())
+        {
            Some((seconds, nanos)) => {
-                let start_index = statement.bind(&seconds, start_index)?;
-                statement.bind(&nanos, start_index)?
+                let start_index = statement.bind(&(seconds as i64), start_index)?;
+                statement.bind(&(nanos as i32), start_index)?
            }
            None => {
                let start_index = statement.bind::<Option<i64>>(&None, start_index)?;
@@ -64,7 +61,7 @@ impl Column for SerializedEditor {

        let mtime = mtime_seconds
            .zip(mtime_nanos)
-            .map(|(seconds, nanos)| UNIX_EPOCH + Duration::new(seconds as u64, nanos as u32));
+            .map(|(seconds, nanos)| MTime::from_seconds_and_nanos(seconds as u64, nanos as u32));

        let editor = Self {
            abs_path,
@@ -280,12 +277,11 @@ mod tests {
        assert_eq!(have, serialized_editor);

        // Storing and retrieving mtime
-        let now = SystemTime::now();
        let serialized_editor = SerializedEditor {
            abs_path: None,
            contents: None,
            language: None,
-            mtime: Some(now),
+            mtime: Some(MTime::from_seconds_and_nanos(100, 42)),
        };

        DB.save_serialized_editor(1234, workspace_id, serialized_editor.clone())
--- a/crates/editor/src/rust_analyzer_ext.rs
+++ b/crates/editor/src/rust_analyzer_ext.rs
@@ -1,3 +1,5 @@
+use std::{fs, path::Path};
+
 use anyhow::Context as _;
 use gpui::{Context, View, ViewContext, VisualContext, WindowContext};
 use language::Language;
@@ -7,7 +9,7 @@ use text::ToPointUtf16;

 use crate::{
    element::register_action, lsp_ext::find_specific_language_server_in_selection, Editor,
-    ExpandMacroRecursively,
+    ExpandMacroRecursively, OpenDocs,
 };

 const RUST_ANALYZER_NAME: &str = "rust-analyzer";
@@ -24,6 +26,7 @@ pub fn apply_related_actions(editor: &View<Editor>, cx: &mut WindowContext) {
        .is_some()
    {
        register_action(editor, cx, expand_macro_recursively);
+        register_action(editor, cx, open_docs);
    }
 }

@@ -94,3 +97,64 @@ pub fn expand_macro_recursively(
    })
    .detach_and_log_err(cx);
 }
+
+pub fn open_docs(editor: &mut Editor, _: &OpenDocs, cx: &mut ViewContext<'_, Editor>) {
+    if editor.selections.count() == 0 {
+        return;
+    }
+    let Some(project) = &editor.project else {
+        return;
+    };
+    let Some(workspace) = editor.workspace() else {
+        return;
+    };
+
+    let Some((trigger_anchor, _rust_language, server_to_query, buffer)) =
+        find_specific_language_server_in_selection(
+            editor,
+            cx,
+            is_rust_language,
+            RUST_ANALYZER_NAME,
+        )
+    else {
+        return;
+    };
+
+    let project = project.clone();
+    let buffer_snapshot = buffer.read(cx).snapshot();
+    let position = trigger_anchor.text_anchor.to_point_utf16(&buffer_snapshot);
+    let open_docs_task = project.update(cx, |project, cx| {
+        project.request_lsp(
+            buffer,
+            project::LanguageServerToQuery::Other(server_to_query),
+            project::lsp_ext_command::OpenDocs { position },
+            cx,
+        )
+    });
+
+    cx.spawn(|_editor, mut cx| async move {
+        let docs_urls = open_docs_task.await.context("open docs")?;
+        if docs_urls.is_empty() {
+            log::debug!("Empty docs urls for position {position:?}");
+            return Ok(());
+        } else {
+            log::debug!("{:?}", docs_urls);
+        }
+
+        workspace.update(&mut cx, |_workspace, cx| {
+            // Check if the local document exists, otherwise fallback to the online document.
+            // Open with the default browser.
+            if let Some(local_url) = docs_urls.local {
+                if fs::metadata(Path::new(&local_url[8..])).is_ok() {
+                    cx.open_url(&local_url);
+                    return;
+                }
+            }
+
+            if let Some(web_url) = docs_urls.web {
+                cx.open_url(&web_url);
+            }
+        })
+    })
+    .detach_and_log_err(cx);
+}
--- a/crates/editor/src/test/editor_lsp_test_context.rs
+++ b/crates/editor/src/test/editor_lsp_test_context.rs
@@ -234,7 +234,16 @@ impl EditorLspTestContext {
                ..Default::default()
            },
            Some(tree_sitter_html::language()),
-        );
+        )
+        .with_queries(LanguageQueries {
+            brackets: Some(Cow::from(indoc! {r#"
+                ("<" @open "/>" @close)
+                ("</" @open ">" @close)
+                ("<" @open ">" @close)
+                ("\"" @open "\"" @close)"#})),
+            ..Default::default()
+        })
+        .expect("Could not parse queries");
        Self::new(language, Default::default(), cx).await
    }

--- a/crates/evals/Cargo.toml
+++ b/crates/evals/Cargo.toml
@@ -30,9 +30,10 @@ languages.workspace = true
 node_runtime.workspace = true
 open_ai.workspace = true
 project.workspace = true
+reqwest_client.workspace = true
 semantic_index.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 settings.workspace = true
 smol.workspace = true
-reqwest_client.workspace = true
+util.workspace = true
--- a/crates/evals/src/eval.rs
+++ b/crates/evals/src/eval.rs
@@ -27,7 +27,7 @@ use std::time::Duration;
 use std::{
    fs,
    path::Path,
-    process::{exit, Command, Stdio},
+    process::{exit, Stdio},
    sync::{
        atomic::{AtomicUsize, Ordering::SeqCst},
        Arc,
@@ -667,7 +667,7 @@ async fn fetch_eval_repo(
        return;
    }
    if !repo_dir.join(".git").exists() {
-        let init_output = Command::new("git")
+        let init_output = util::command::new_std_command("git")
            .current_dir(&repo_dir)
            .args(&["init"])
            .output()
@@ -682,13 +682,13 @@ async fn fetch_eval_repo(
        }
    }
    let url = format!("https://github.com/{}.git", repo);
-    Command::new("git")
+    util::command::new_std_command("git")
        .current_dir(&repo_dir)
        .args(&["remote", "add", "-f", "origin", &url])
        .stdin(Stdio::null())
        .output()
        .unwrap();
-    let fetch_output = Command::new("git")
+    let fetch_output = util::command::new_std_command("git")
        .current_dir(&repo_dir)
        .args(&["fetch", "--depth", "1", "origin", &sha])
        .stdin(Stdio::null())
@@ -703,7 +703,7 @@ async fn fetch_eval_repo(
        );
        return;
    }
-    let checkout_output = Command::new("git")
+    let checkout_output = util::command::new_std_command("git")
        .current_dir(&repo_dir)
        .args(&["checkout", &sha])
        .output()
--- a/crates/extension/Cargo.toml
+++ b/crates/extension/Cargo.toml
@@ -24,10 +24,12 @@ http_client.workspace = true
 language.workspace = true
 log.workspace = true
 lsp.workspace = true
+parking_lot.workspace = true
 semantic_version.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 toml.workspace = true
+util.workspace = true
 wasm-encoder.workspace = true
 wasmparser.workspace = true
 wit-component.workspace = true
--- a/crates/extension/src/extension.rs
+++ b/crates/extension/src/extension.rs
@@ -1,17 +1,27 @@
 pub mod extension_builder;
+mod extension_host_proxy;
 mod extension_manifest;
-mod slash_command;
+mod types;

 use std::path::{Path, PathBuf};
 use std::sync::Arc;

+use ::lsp::LanguageServerName;
 use anyhow::{anyhow, bail, Context as _, Result};
 use async_trait::async_trait;
-use gpui::Task;
+use fs::normalize_path;
+use gpui::{AppContext, Task};
+use language::LanguageName;
 use semantic_version::SemanticVersion;

+pub use crate::extension_host_proxy::*;
 pub use crate::extension_manifest::*;
-pub use crate::slash_command::*;
+pub use crate::types::*;
+
+/// Initializes the `extension` crate.
+pub fn init(cx: &mut AppContext) {
+    ExtensionHostProxy::default_global(cx);
+}

 #[async_trait]
 pub trait WorktreeDelegate: Send + Sync + 'static {
@@ -22,6 +32,10 @@ pub trait WorktreeDelegate: Send + Sync + 'static {
    async fn shell_env(&self) -> Vec<(String, String)>;
 }

+pub trait ProjectDelegate: Send + Sync + 'static {
+    fn worktree_ids(&self) -> Vec<u64>;
+}
+
 pub trait KeyValueStoreDelegate: Send + Sync + 'static {
    fn insert(&self, key: String, docs: String) -> Task<Result<()>>;
 }
@@ -34,6 +48,43 @@ pub trait Extension: Send + Sync + 'static {
    /// Returns the path to this extension's working directory.
    fn work_dir(&self) -> Arc<Path>;

+    /// Returns a path relative to this extension's working directory.
+    fn path_from_extension(&self, path: &Path) -> PathBuf {
+        normalize_path(&self.work_dir().join(path))
+    }
+
+    async fn language_server_command(
+        &self,
+        language_server_id: LanguageServerName,
+        language_name: LanguageName,
+        worktree: Arc<dyn WorktreeDelegate>,
+    ) -> Result<Command>;
+
+    async fn language_server_initialization_options(
+        &self,
+        language_server_id: LanguageServerName,
+        language_name: LanguageName,
+        worktree: Arc<dyn WorktreeDelegate>,
+    ) -> Result<Option<String>>;
+
+    async fn language_server_workspace_configuration(
+        &self,
+        language_server_id: LanguageServerName,
+        worktree: Arc<dyn WorktreeDelegate>,
+    ) -> Result<Option<String>>;
+
+    async fn labels_for_completions(
+        &self,
+        language_server_id: LanguageServerName,
+        completions: Vec<Completion>,
+    ) -> Result<Vec<Option<CodeLabel>>>;
+
+    async fn labels_for_symbols(
+        &self,
+        language_server_id: LanguageServerName,
+        symbols: Vec<Symbol>,
+    ) -> Result<Vec<Option<CodeLabel>>>;
+
    async fn complete_slash_command_argument(
        &self,
        command: SlashCommand,
@@ -44,9 +95,15 @@ pub trait Extension: Send + Sync + 'static {
        &self,
        command: SlashCommand,
        arguments: Vec<String>,
-        resource: Option<Arc<dyn WorktreeDelegate>>,
+        worktree: Option<Arc<dyn WorktreeDelegate>>,
    ) -> Result<SlashCommandOutput>;

+    async fn context_server_command(
+        &self,
+        context_server_id: Arc<str>,
+        project: Arc<dyn ProjectDelegate>,
+    ) -> Result<Command>;
+
    async fn suggest_docs_packages(&self, provider: Arc<str>) -> Result<Vec<String>>;

    async fn index_docs(
--- a/crates/extension/src/extension_builder.rs
+++ b/crates/extension/src/extension_builder.rs
@@ -11,7 +11,7 @@ use serde::Deserialize;
 use std::{
    env, fs, mem,
    path::{Path, PathBuf},
-    process::{Command, Stdio},
+    process::Stdio,
    sync::Arc,
 };
 use wasm_encoder::{ComponentSectionId, Encode as _, RawSection, Section as _};
@@ -130,7 +130,7 @@ impl ExtensionBuilder {
            "compiling Rust crate for extension {}",
            extension_dir.display()
        );
-        let output = Command::new("cargo")
+        let output = util::command::new_std_command("cargo")
            .args(["build", "--target", RUST_TARGET])
            .args(options.release.then_some("--release"))
            .arg("--target-dir")
@@ -237,7 +237,7 @@ impl ExtensionBuilder {
        let scanner_path = src_path.join("scanner.c");

        log::info!("compiling {grammar_name} parser");
-        let clang_output = Command::new(&clang_path)
+        let clang_output = util::command::new_std_command(&clang_path)
            .args(["-fPIC", "-shared", "-Os"])
            .arg(format!("-Wl,--export=tree_sitter_{grammar_name}"))
            .arg("-o")
@@ -264,7 +264,7 @@ impl ExtensionBuilder {
        let git_dir = directory.join(".git");

        if directory.exists() {
-            let remotes_output = Command::new("git")
+            let remotes_output = util::command::new_std_command("git")
                .arg("--git-dir")
                .arg(&git_dir)
                .args(["remote", "-v"])
@@ -287,7 +287,7 @@ impl ExtensionBuilder {
            fs::create_dir_all(directory).with_context(|| {
                format!("failed to create grammar directory {}", directory.display(),)
            })?;
-            let init_output = Command::new("git")
+            let init_output = util::command::new_std_command("git")
                .arg("init")
                .current_dir(directory)
                .output()?;
@@ -298,7 +298,7 @@ impl ExtensionBuilder {
                );
            }

-            let remote_add_output = Command::new("git")
+            let remote_add_output = util::command::new_std_command("git")
                .arg("--git-dir")
                .arg(&git_dir)
                .args(["remote", "add", "origin", url])
@@ -312,14 +312,14 @@ impl ExtensionBuilder {
            }
        }

-        let fetch_output = Command::new("git")
+        let fetch_output = util::command::new_std_command("git")
            .arg("--git-dir")
            .arg(&git_dir)
            .args(["fetch", "--depth", "1", "origin", rev])
            .output()
            .context("failed to execute `git fetch`")?;

-        let checkout_output = Command::new("git")
+        let checkout_output = util::command::new_std_command("git")
            .arg("--git-dir")
            .arg(&git_dir)
            .args(["checkout", rev])
@@ -346,7 +346,7 @@ impl ExtensionBuilder {
    }

    fn install_rust_wasm_target_if_needed(&self) -> Result<()> {
-        let rustc_output = Command::new("rustc")
+        let rustc_output = util::command::new_std_command("rustc")
            .arg("--print")
            .arg("sysroot")
            .output()
@@ -363,7 +363,7 @@ impl ExtensionBuilder {
            return Ok(());
        }

-        let output = Command::new("rustup")
+        let output = util::command::new_std_command("rustup")
            .args(["target", "add", RUST_TARGET])
            .stderr(Stdio::piped())
            .stdout(Stdio::inherit())
--- a/crates/extension/src/extension_host_proxy.rs
+++ b/crates/extension/src/extension_host_proxy.rs
@@ -0,0 +1,324 @@
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use anyhow::Result;
+use fs::Fs;
+use gpui::{AppContext, Global, ReadGlobal, SharedString, Task};
+use language::{LanguageMatcher, LanguageName, LanguageServerBinaryStatus, LoadedLanguage};
+use lsp::LanguageServerName;
+use parking_lot::RwLock;
+
+use crate::{Extension, SlashCommand};
+
+#[derive(Default)]
+struct GlobalExtensionHostProxy(Arc<ExtensionHostProxy>);
+
+impl Global for GlobalExtensionHostProxy {}
+
+/// A proxy for interacting with the extension host.
+///
+/// This object implements each of the individual proxy types so that their
+/// methods can be called directly on it.
+#[derive(Default)]
+pub struct ExtensionHostProxy {
+    theme_proxy: RwLock<Option<Arc<dyn ExtensionThemeProxy>>>,
+    grammar_proxy: RwLock<Option<Arc<dyn ExtensionGrammarProxy>>>,
+    language_proxy: RwLock<Option<Arc<dyn ExtensionLanguageProxy>>>,
+    language_server_proxy: RwLock<Option<Arc<dyn ExtensionLanguageServerProxy>>>,
+    snippet_proxy: RwLock<Option<Arc<dyn ExtensionSnippetProxy>>>,
+    slash_command_proxy: RwLock<Option<Arc<dyn ExtensionSlashCommandProxy>>>,
+    context_server_proxy: RwLock<Option<Arc<dyn ExtensionContextServerProxy>>>,
+    indexed_docs_provider_proxy: RwLock<Option<Arc<dyn ExtensionIndexedDocsProviderProxy>>>,
+}
+
+impl ExtensionHostProxy {
+    /// Returns the global [`ExtensionHostProxy`].
+    pub fn global(cx: &AppContext) -> Arc<Self> {
+        GlobalExtensionHostProxy::global(cx).0.clone()
+    }
+
+    /// Returns the global [`ExtensionHostProxy`].
+    ///
+    /// Inserts a default [`ExtensionHostProxy`] if one does not yet exist.
+    pub fn default_global(cx: &mut AppContext) -> Arc<Self> {
+        cx.default_global::<GlobalExtensionHostProxy>().0.clone()
+    }
+
+    pub fn new() -> Self {
+        Self {
+            theme_proxy: RwLock::default(),
+            grammar_proxy: RwLock::default(),
+            language_proxy: RwLock::default(),
+            language_server_proxy: RwLock::default(),
+            snippet_proxy: RwLock::default(),
+            slash_command_proxy: RwLock::default(),
+            context_server_proxy: RwLock::default(),
+            indexed_docs_provider_proxy: RwLock::default(),
+        }
+    }
+
+    pub fn register_theme_proxy(&self, proxy: impl ExtensionThemeProxy) {
+        self.theme_proxy.write().replace(Arc::new(proxy));
+    }
+
+    pub fn register_grammar_proxy(&self, proxy: impl ExtensionGrammarProxy) {
+        self.grammar_proxy.write().replace(Arc::new(proxy));
+    }
+
+    pub fn register_language_proxy(&self, proxy: impl ExtensionLanguageProxy) {
+        self.language_proxy.write().replace(Arc::new(proxy));
+    }
+
+    pub fn register_language_server_proxy(&self, proxy: impl ExtensionLanguageServerProxy) {
+        self.language_server_proxy.write().replace(Arc::new(proxy));
+    }
+
+    pub fn register_snippet_proxy(&self, proxy: impl ExtensionSnippetProxy) {
+        self.snippet_proxy.write().replace(Arc::new(proxy));
+    }
+
+    pub fn register_slash_command_proxy(&self, proxy: impl ExtensionSlashCommandProxy) {
+        self.slash_command_proxy.write().replace(Arc::new(proxy));
+    }
+
+    pub fn register_context_server_proxy(&self, proxy: impl ExtensionContextServerProxy) {
+        self.context_server_proxy.write().replace(Arc::new(proxy));
+    }
+
+    pub fn register_indexed_docs_provider_proxy(
+        &self,
+        proxy: impl ExtensionIndexedDocsProviderProxy,
+    ) {
+        self.indexed_docs_provider_proxy
+            .write()
+            .replace(Arc::new(proxy));
+    }
+}
+
+pub trait ExtensionThemeProxy: Send + Sync + 'static {
+    fn list_theme_names(&self, theme_path: PathBuf, fs: Arc<dyn Fs>) -> Task<Result<Vec<String>>>;
+
+    fn remove_user_themes(&self, themes: Vec<SharedString>);
+
+    fn load_user_theme(&self, theme_path: PathBuf, fs: Arc<dyn Fs>) -> Task<Result<()>>;
+
+    fn reload_current_theme(&self, cx: &mut AppContext);
+}
+
+impl ExtensionThemeProxy for ExtensionHostProxy {
+    fn list_theme_names(&self, theme_path: PathBuf, fs: Arc<dyn Fs>) -> Task<Result<Vec<String>>> {
+        let Some(proxy) = self.theme_proxy.read().clone() else {
+            return Task::ready(Ok(Vec::new()));
+        };
+
+        proxy.list_theme_names(theme_path, fs)
+    }
+
+    fn remove_user_themes(&self, themes: Vec<SharedString>) {
+        let Some(proxy) = self.theme_proxy.read().clone() else {
+            return;
+        };
+
+        proxy.remove_user_themes(themes)
+    }
+
+    fn load_user_theme(&self, theme_path: PathBuf, fs: Arc<dyn Fs>) -> Task<Result<()>> {
+        let Some(proxy) = self.theme_proxy.read().clone() else {
+            return Task::ready(Ok(()));
+        };
+
+        proxy.load_user_theme(theme_path, fs)
+    }
+
+    fn reload_current_theme(&self, cx: &mut AppContext) {
+        let Some(proxy) = self.theme_proxy.read().clone() else {
+            return;
+        };
+
+        proxy.reload_current_theme(cx)
+    }
+}
+
+pub trait ExtensionGrammarProxy: Send + Sync + 'static {
+    fn register_grammars(&self, grammars: Vec<(Arc<str>, PathBuf)>);
+}
+
+impl ExtensionGrammarProxy for ExtensionHostProxy {
+    fn register_grammars(&self, grammars: Vec<(Arc<str>, PathBuf)>) {
+        let Some(proxy) = self.grammar_proxy.read().clone() else {
+            return;
+        };
+
+        proxy.register_grammars(grammars)
+    }
+}
+
+pub trait ExtensionLanguageProxy: Send + Sync + 'static {
+    fn register_language(
+        &self,
+        language: LanguageName,
+        grammar: Option<Arc<str>>,
+        matcher: LanguageMatcher,
+        load: Arc<dyn Fn() -> Result<LoadedLanguage> + Send + Sync + 'static>,
+    );
+
+    fn remove_languages(
+        &self,
+        languages_to_remove: &[LanguageName],
+        grammars_to_remove: &[Arc<str>],
+    );
+}
+
+impl ExtensionLanguageProxy for ExtensionHostProxy {
+    fn register_language(
+        &self,
+        language: LanguageName,
+        grammar: Option<Arc<str>>,
+        matcher: LanguageMatcher,
+        load: Arc<dyn Fn() -> Result<LoadedLanguage> + Send + Sync + 'static>,
+    ) {
+        let Some(proxy) = self.language_proxy.read().clone() else {
+            return;
+        };
+
+        proxy.register_language(language, grammar, matcher, load)
+    }
+
+    fn remove_languages(
+        &self,
+        languages_to_remove: &[LanguageName],
+        grammars_to_remove: &[Arc<str>],
+    ) {
+        let Some(proxy) = self.language_proxy.read().clone() else {
+            return;
+        };
+
+        proxy.remove_languages(languages_to_remove, grammars_to_remove)
+    }
+}
+
+pub trait ExtensionLanguageServerProxy: Send + Sync + 'static {
+    fn register_language_server(
+        &self,
+        extension: Arc<dyn Extension>,
+        language_server_id: LanguageServerName,
+        language: LanguageName,
+    );
+
+    fn remove_language_server(
+        &self,
+        language: &LanguageName,
+        language_server_id: &LanguageServerName,
+    );
+
+    fn update_language_server_status(
+        &self,
+        language_server_id: LanguageServerName,
+        status: LanguageServerBinaryStatus,
+    );
+}
+
+impl ExtensionLanguageServerProxy for ExtensionHostProxy {
+    fn register_language_server(
+        &self,
+        extension: Arc<dyn Extension>,
+        language_server_id: LanguageServerName,
+        language: LanguageName,
+    ) {
+        let Some(proxy) = self.language_server_proxy.read().clone() else {
+            return;
+        };
+
+        proxy.register_language_server(extension, language_server_id, language)
+    }
+
+    fn remove_language_server(
+        &self,
+        language: &LanguageName,
+        language_server_id: &LanguageServerName,
+    ) {
+        let Some(proxy) = self.language_server_proxy.read().clone() else {
+            return;
+        };
+
+        proxy.remove_language_server(language, language_server_id)
+    }
+
+    fn update_language_server_status(
+        &self,
+        language_server_id: LanguageServerName,
+        status: LanguageServerBinaryStatus,
+    ) {
+        let Some(proxy) = self.language_server_proxy.read().clone() else {
+            return;
+        };
+
+        proxy.update_language_server_status(language_server_id, status)
+    }
+}
+
+pub trait ExtensionSnippetProxy: Send + Sync + 'static {
+    fn register_snippet(&self, path: &PathBuf, snippet_contents: &str) -> Result<()>;
+}
+
+impl ExtensionSnippetProxy for ExtensionHostProxy {
+    fn register_snippet(&self, path: &PathBuf, snippet_contents: &str) -> Result<()> {
+        let Some(proxy) = self.snippet_proxy.read().clone() else {
+            return Ok(());
+        };
+
+        proxy.register_snippet(path, snippet_contents)
+    }
+}
+
+pub trait ExtensionSlashCommandProxy: Send + Sync + 'static {
+    fn register_slash_command(&self, extension: Arc<dyn Extension>, command: SlashCommand);
+}
+
+impl ExtensionSlashCommandProxy for ExtensionHostProxy {
+    fn register_slash_command(&self, extension: Arc<dyn Extension>, command: SlashCommand) {
+        let Some(proxy) = self.slash_command_proxy.read().clone() else {
+            return;
+        };
+
+        proxy.register_slash_command(extension, command)
+    }
+}
+
+pub trait ExtensionContextServerProxy: Send + Sync + 'static {
+    fn register_context_server(
+        &self,
+        extension: Arc<dyn Extension>,
+        server_id: Arc<str>,
+        cx: &mut AppContext,
+    );
+}
+
+impl ExtensionContextServerProxy for ExtensionHostProxy {
+    fn register_context_server(
+        &self,
+        extension: Arc<dyn Extension>,
+        server_id: Arc<str>,
+        cx: &mut AppContext,
+    ) {
+        let Some(proxy) = self.context_server_proxy.read().clone() else {
+            return;
+        };
+
+        proxy.register_context_server(extension, server_id, cx)
+    }
+}
+
+pub trait ExtensionIndexedDocsProviderProxy: Send + Sync + 'static {
+    fn register_indexed_docs_provider(&self, extension: Arc<dyn Extension>, provider_id: Arc<str>);
+}
+
+impl ExtensionIndexedDocsProviderProxy for ExtensionHostProxy {
+    fn register_indexed_docs_provider(&self, extension: Arc<dyn Extension>, provider_id: Arc<str>) {
+        let Some(proxy) = self.indexed_docs_provider_proxy.read().clone() else {
+            return;
+        };
+
+        proxy.register_indexed_docs_provider(extension, provider_id)
+    }
+}
--- a/crates/extension/src/types.rs
+++ b/crates/extension/src/types.rs
@@ -0,0 +1,50 @@
+mod lsp;
+mod slash_command;
+
+use std::ops::Range;
+
+pub use lsp::*;
+pub use slash_command::*;
+
+/// A list of environment variables.
+pub type EnvVars = Vec<(String, String)>;
+
+/// A command.
+#[derive(Debug)]
+pub struct Command {
+    /// The command to execute.
+    pub command: String,
+    /// The arguments to pass to the command.
+    pub args: Vec<String>,
+    /// The environment variables to set for the command.
+    pub env: EnvVars,
+}
+
+/// A label containing some code.
+#[derive(Debug, Clone)]
+pub struct CodeLabel {
+    /// The source code to parse with Tree-sitter.
+    pub code: String,
+    /// The spans to display in the label.
+    pub spans: Vec<CodeLabelSpan>,
+    /// The range of the displayed label to include when filtering.
+    pub filter_range: Range<usize>,
+}
+
+/// A span within a code label.
+#[derive(Debug, Clone)]
+pub enum CodeLabelSpan {
+    /// A range into the parsed code.
+    CodeRange(Range<usize>),
+    /// A span containing a code literal.
+    Literal(CodeLabelSpanLiteral),
+}
+
+/// A span containing a code literal.
+#[derive(Debug, Clone)]
+pub struct CodeLabelSpanLiteral {
+    /// The literal text.
+    pub text: String,
+    /// The name of the highlight to use for this literal.
+    pub highlight_name: Option<String>,
+}
--- a/crates/extension/src/types/lsp.rs
+++ b/crates/extension/src/types/lsp.rs
@@ -0,0 +1,96 @@
+use std::option::Option;
+
+/// An LSP completion.
+#[derive(Debug, Clone)]
+pub struct Completion {
+    pub label: String,
+    pub label_details: Option<CompletionLabelDetails>,
+    pub detail: Option<String>,
+    pub kind: Option<CompletionKind>,
+    pub insert_text_format: Option<InsertTextFormat>,
+}
+
+/// The kind of an LSP completion.
+#[derive(Debug, Clone, Copy)]
+pub enum CompletionKind {
+    Text,
+    Method,
+    Function,
+    Constructor,
+    Field,
+    Variable,
+    Class,
+    Interface,
+    Module,
+    Property,
+    Unit,
+    Value,
+    Enum,
+    Keyword,
+    Snippet,
+    Color,
+    File,
+    Reference,
+    Folder,
+    EnumMember,
+    Constant,
+    Struct,
+    Event,
+    Operator,
+    TypeParameter,
+    Other(i32),
+}
+
+/// Label details for an LSP completion.
+#[derive(Debug, Clone)]
+pub struct CompletionLabelDetails {
+    pub detail: Option<String>,
+    pub description: Option<String>,
+}
+
+/// Defines how to interpret the insert text in a completion item.
+#[derive(Debug, Clone, Copy)]
+pub enum InsertTextFormat {
+    PlainText,
+    Snippet,
+    Other(i32),
+}
+
+/// An LSP symbol.
+#[derive(Debug, Clone)]
+pub struct Symbol {
+    pub kind: SymbolKind,
+    pub name: String,
+}
+
+/// The kind of an LSP symbol.
+#[derive(Debug, Clone, Copy)]
+pub enum SymbolKind {
+    File,
+    Module,
+    Namespace,
+    Package,
+    Class,
+    Method,
+    Property,
+    Field,
+    Constructor,
+    Enum,
+    Interface,
+    Function,
+    Variable,
+    Constant,
+    String,
+    Number,
+    Boolean,
+    Array,
+    Object,
+    Key,
+    Null,
+    EnumMember,
+    Struct,
+    Event,
+    Operator,
+    TypeParameter,
+    Other(i32),
+}
--- a/crates/extension/src/types/slash_command.rs
+++ b/crates/extension/src/types/slash_command.rs
--- a/crates/extension_api/Cargo.toml
+++ b/crates/extension_api/Cargo.toml
@@ -8,9 +8,6 @@ keywords = ["zed", "extension"]
 edition = "2021"
 license = "Apache-2.0"

-# Remove when we're ready to publish v0.2.0.
-publish = false
-
 [lints]
 workspace = true

--- a/crates/extension_api/README.md
+++ b/crates/extension_api/README.md
@@ -63,6 +63,7 @@ Here is the compatibility of the `zed_extension_api` with versions of Zed:

 | Zed version | `zed_extension_api` version |
 | ----------- | --------------------------- |
+| `0.162.x`   | `0.0.1` - `0.2.0`           |
 | `0.149.x`   | `0.0.1` - `0.1.0`           |
 | `0.131.x`   | `0.0.1` - `0.0.6`           |
 | `0.130.x`   | `0.0.1` - `0.0.5`           |
--- a/crates/extension_host/Cargo.toml
+++ b/crates/extension_host/Cargo.toml
@@ -34,6 +34,7 @@ lsp.workspace = true
 node_runtime.workspace = true
 paths.workspace = true
 project.workspace = true
+remote.workspace = true
 release_channel.workspace = true
 schemars.workspace = true
 semantic_version.workspace = true
@@ -42,6 +43,7 @@ serde_json.workspace = true
 serde_json_lenient.workspace = true
 settings.workspace = true
 task.workspace = true
+tempfile.workspace = true
 toml.workspace = true
 url.workspace = true
 util.workspace = true
@@ -55,6 +57,9 @@ env_logger.workspace = true
 fs = { workspace = true, features = ["test-support"] }
 gpui = { workspace = true, features = ["test-support"] }
 language = { workspace = true, features = ["test-support"] }
+language_extension.workspace = true
 parking_lot.workspace = true
 project = { workspace = true, features = ["test-support"] }
 reqwest_client.workspace = true
+theme = { workspace = true, features = ["test-support"] }
+theme_extension.workspace = true
--- a/crates/extension_host/src/extension_host.rs
+++ b/crates/extension_host/src/extension_host.rs
@@ -1,16 +1,22 @@
-pub mod extension_lsp_adapter;
 pub mod extension_settings;
+pub mod headless_host;
 pub mod wasm_host;

-use crate::{extension_lsp_adapter::ExtensionLspAdapter, wasm_host::wit};
+#[cfg(test)]
+mod extension_store_test;
+
 use anyhow::{anyhow, bail, Context as _, Result};
 use async_compression::futures::bufread::GzipDecoder;
 use async_tar::Archive;
-use client::{telemetry::Telemetry, Client, ExtensionMetadata, GetExtensionsResponse};
-use collections::{btree_map, BTreeMap, HashSet};
+use client::{proto, telemetry::Telemetry, Client, ExtensionMetadata, GetExtensionsResponse};
+use collections::{btree_map, BTreeMap, HashMap, HashSet};
 use extension::extension_builder::{CompileExtensionOptions, ExtensionBuilder};
-use extension::Extension;
 pub use extension::ExtensionManifest;
+use extension::{
+    ExtensionContextServerProxy, ExtensionGrammarProxy, ExtensionHostProxy,
+    ExtensionIndexedDocsProviderProxy, ExtensionLanguageProxy, ExtensionLanguageServerProxy,
+    ExtensionSlashCommandProxy, ExtensionSnippetProxy, ExtensionThemeProxy,
+};
 use fs::{Fs, RemoveOptions};
 use futures::{
    channel::{
@@ -21,18 +27,18 @@ use futures::{
    select_biased, AsyncReadExt as _, Future, FutureExt as _, StreamExt as _,
 };
 use gpui::{
-    actions, AppContext, AsyncAppContext, Context, EventEmitter, Global, Model, ModelContext,
-    SharedString, Task, WeakModel,
+    actions, AppContext, AsyncAppContext, Context, EventEmitter, Global, Model, ModelContext, Task,
+    WeakModel,
 };
 use http_client::{AsyncBody, HttpClient, HttpClientWithUrl};
 use language::{
    LanguageConfig, LanguageMatcher, LanguageName, LanguageQueries, LoadedLanguage,
    QUERY_FILENAME_PREFIXES,
 };
-use lsp::LanguageServerName;
 use node_runtime::NodeRuntime;
 use project::ContextProviderWithTasks;
 use release_channel::ReleaseChannel;
+use remote::SshRemoteClient;
 use semantic_version::SemanticVersion;
 use serde::{Deserialize, Serialize};
 use settings::Settings;
@@ -91,76 +97,8 @@ pub fn is_version_compatible(
    true
 }

-pub trait ExtensionRegistrationHooks: Send + Sync + 'static {
-    fn remove_user_themes(&self, _themes: Vec<SharedString>) {}
-
-    fn load_user_theme(&self, _theme_path: PathBuf, _fs: Arc<dyn Fs>) -> Task<Result<()>> {
-        Task::ready(Ok(()))
-    }
-
-    fn list_theme_names(
-        &self,
-        _theme_path: PathBuf,
-        _fs: Arc<dyn Fs>,
-    ) -> Task<Result<Vec<String>>> {
-        Task::ready(Ok(Vec::new()))
-    }
-
-    fn reload_current_theme(&self, _cx: &mut AppContext) {}
-
-    fn register_language(
-        &self,
-        _language: LanguageName,
-        _grammar: Option<Arc<str>>,
-        _matcher: language::LanguageMatcher,
-        _load: Arc<dyn Fn() -> Result<LoadedLanguage> + 'static + Send + Sync>,
-    ) {
-    }
-
-    fn register_lsp_adapter(&self, _language: LanguageName, _adapter: ExtensionLspAdapter) {}
-
-    fn remove_lsp_adapter(&self, _language: &LanguageName, _server_name: &LanguageServerName) {}
-
-    fn register_wasm_grammars(&self, _grammars: Vec<(Arc<str>, PathBuf)>) {}
-
-    fn remove_languages(
-        &self,
-        _languages_to_remove: &[LanguageName],
-        _grammars_to_remove: &[Arc<str>],
-    ) {
-    }
-
-    fn register_slash_command(
-        &self,
-        _extension: Arc<dyn Extension>,
-        _command: extension::SlashCommand,
-    ) {
-    }
-
-    fn register_context_server(
-        &self,
-        _id: Arc<str>,
-        _extension: WasmExtension,
-        _cx: &mut AppContext,
-    ) {
-    }
-
-    fn register_docs_provider(&self, _extension: Arc<dyn Extension>, _provider_id: Arc<str>) {}
-
-    fn register_snippets(&self, _path: &PathBuf, _snippet_contents: &str) -> Result<()> {
-        Ok(())
-    }
-
-    fn update_lsp_status(
-        &self,
-        _server_name: lsp::LanguageServerName,
-        _status: language::LanguageServerBinaryStatus,
-    ) {
-    }
-}
-
 pub struct ExtensionStore {
-    pub registration_hooks: Arc<dyn ExtensionRegistrationHooks>,
+    pub proxy: Arc<ExtensionHostProxy>,
    pub builder: Arc<ExtensionBuilder>,
    pub extension_index: ExtensionIndex,
    pub fs: Arc<dyn Fs>,
@@ -175,6 +113,8 @@ pub struct ExtensionStore {
    pub wasm_host: Arc<WasmHost>,
    pub wasm_extensions: Vec<(Arc<ExtensionManifest>, WasmExtension)>,
    pub tasks: Vec<Task<()>>,
+    pub ssh_clients: HashMap<String, WeakModel<SshRemoteClient>>,
+    pub ssh_registered_tx: UnboundedSender<()>,
 }

 #[derive(Clone, Copy)]
@@ -228,7 +168,7 @@ pub struct ExtensionIndexLanguageEntry {
 actions!(zed, [ReloadExtensions]);

 pub fn init(
-    registration_hooks: Arc<dyn ExtensionRegistrationHooks>,
+    extension_host_proxy: Arc<ExtensionHostProxy>,
    fs: Arc<dyn Fs>,
    client: Arc<Client>,
    node_runtime: NodeRuntime,
@@ -240,7 +180,7 @@ pub fn init(
        ExtensionStore::new(
            paths::extensions_dir().clone(),
            None,
-            registration_hooks,
+            extension_host_proxy,
            fs,
            client.http_client().clone(),
            client.http_client().clone(),
@@ -272,7 +212,7 @@ impl ExtensionStore {
    pub fn new(
        extensions_dir: PathBuf,
        build_dir: Option<PathBuf>,
-        extension_api: Arc<dyn ExtensionRegistrationHooks>,
+        extension_host_proxy: Arc<ExtensionHostProxy>,
        fs: Arc<dyn Fs>,
        http_client: Arc<HttpClientWithUrl>,
        builder_client: Arc<dyn HttpClient>,
@@ -286,8 +226,9 @@ impl ExtensionStore {
        let index_path = extensions_dir.join("index.json");

        let (reload_tx, mut reload_rx) = unbounded();
+        let (connection_registered_tx, mut connection_registered_rx) = unbounded();
        let mut this = Self {
-            registration_hooks: extension_api.clone(),
+            proxy: extension_host_proxy.clone(),
            extension_index: Default::default(),
            installed_dir,
            index_path,
@@ -299,7 +240,7 @@ impl ExtensionStore {
                fs.clone(),
                http_client.clone(),
                node_runtime,
-                extension_api,
+                extension_host_proxy,
                work_dir,
                cx,
            ),
@@ -309,6 +250,9 @@ impl ExtensionStore {
            telemetry,
            reload_tx,
            tasks: Vec::new(),
+
+            ssh_clients: HashMap::default(),
+            ssh_registered_tx: connection_registered_tx,
        };

        // The extensions store maintains an index file, which contains a complete
@@ -334,7 +278,10 @@ impl ExtensionStore {
                if let (Ok(Some(index_metadata)), Ok(Some(extensions_metadata))) =
                    (index_metadata, extensions_metadata)
                {
-                    if index_metadata.mtime > extensions_metadata.mtime {
+                    if index_metadata
+                        .mtime
+                        .bad_is_greater_than(extensions_metadata.mtime)
+                    {
                        extension_index_needs_rebuild = false;
                    }
                }
@@ -383,6 +330,14 @@ impl ExtensionStore {
                                    .await;
                                index_changed = false;
                            }
+
+                            Self::update_ssh_clients(&this, &mut cx).await?;
+                        }
+                        _ = connection_registered_rx.next() => {
+                            debounce_timer = cx
+                                .background_executor()
+                                .timer(RELOAD_DEBOUNCE_DURATION)
+                                .fuse();
                        }
                        extension_id = reload_rx.next() => {
                            let Some(extension_id) = extension_id else { break; };
@@ -1086,16 +1041,16 @@ impl ExtensionStore {
            grammars_to_remove.extend(extension.manifest.grammars.keys().cloned());
            for (language_server_name, config) in extension.manifest.language_servers.iter() {
                for language in config.languages() {
-                    self.registration_hooks
-                        .remove_lsp_adapter(&language, language_server_name);
+                    self.proxy
+                        .remove_language_server(&language, language_server_name);
                }
            }
        }

        self.wasm_extensions
            .retain(|(extension, _)| !extensions_to_unload.contains(&extension.id));
-        self.registration_hooks.remove_user_themes(themes_to_remove);
-        self.registration_hooks
+        self.proxy.remove_user_themes(themes_to_remove);
+        self.proxy
            .remove_languages(&languages_to_remove, &grammars_to_remove);

        let languages_to_add = new_index
@@ -1130,8 +1085,7 @@ impl ExtensionStore {
            }));
        }

-        self.registration_hooks
-            .register_wasm_grammars(grammars_to_add);
+        self.proxy.register_grammars(grammars_to_add);

        for (language_name, language) in languages_to_add {
            let mut language_path = self.installed_dir.clone();
@@ -1139,7 +1093,7 @@ impl ExtensionStore {
                Path::new(language.extension.as_ref()),
                language.path.as_path(),
            ]);
-            self.registration_hooks.register_language(
+            self.proxy.register_language(
                language_name.clone(),
                language.grammar.clone(),
                language.matcher.clone(),
@@ -1169,7 +1123,7 @@ impl ExtensionStore {
        let fs = self.fs.clone();
        let wasm_host = self.wasm_host.clone();
        let root_dir = self.installed_dir.clone();
-        let api = self.registration_hooks.clone();
+        let proxy = self.proxy.clone();
        let extension_entries = extensions_to_load
            .iter()
            .filter_map(|name| new_index.extensions.get(name).cloned())
@@ -1185,13 +1139,17 @@ impl ExtensionStore {
                    let fs = fs.clone();
                    async move {
                        for theme_path in themes_to_add.into_iter() {
-                            api.load_user_theme(theme_path, fs.clone()).await.log_err();
+                            proxy
+                                .load_user_theme(theme_path, fs.clone())
+                                .await
+                                .log_err();
                        }

                        for snippets_path in &snippets_to_add {
                            if let Some(snippets_contents) = fs.load(snippets_path).await.log_err()
                            {
-                                api.register_snippets(snippets_path, &snippets_contents)
+                                proxy
+                                    .register_snippet(snippets_path, &snippets_contents)
                                    .log_err();
                            }
                        }
@@ -1232,23 +1190,16 @@ impl ExtensionStore {

                    for (language_server_id, language_server_config) in &manifest.language_servers {
                        for language in language_server_config.languages() {
-                            this.registration_hooks.register_lsp_adapter(
+                            this.proxy.register_language_server(
+                                extension.clone(),
+                                language_server_id.clone(),
                                language.clone(),
-                                ExtensionLspAdapter {
-                                    extension: wasm_extension.clone(),
-                                    host: this.wasm_host.clone(),
-                                    language_server_id: language_server_id.clone(),
-                                    config: wit::LanguageServerConfig {
-                                        name: language_server_id.0.to_string(),
-                                        language_name: language.to_string(),
-                                    },
-                                },
                            );
                        }
                    }

                    for (slash_command_name, slash_command) in &manifest.slash_commands {
-                        this.registration_hooks.register_slash_command(
+                        this.proxy.register_slash_command(
                            extension.clone(),
                            extension::SlashCommand {
                                name: slash_command_name.to_string(),
@@ -1263,21 +1214,18 @@ impl ExtensionStore {
                    }

                    for (id, _context_server_entry) in &manifest.context_servers {
-                        this.registration_hooks.register_context_server(
-                            id.clone(),
-                            wasm_extension.clone(),
-                            cx,
-                        );
+                        this.proxy
+                            .register_context_server(extension.clone(), id.clone(), cx);
                    }

                    for (provider_id, _provider) in &manifest.indexed_docs_providers {
-                        this.registration_hooks
-                            .register_docs_provider(extension.clone(), provider_id.clone());
+                        this.proxy
+                            .register_indexed_docs_provider(extension.clone(), provider_id.clone());
                    }
                }

                this.wasm_extensions.extend(wasm_extensions);
-                this.registration_hooks.reload_current_theme(cx);
+                this.proxy.reload_current_theme(cx);
            })
            .ok();
        })
@@ -1288,7 +1236,7 @@ impl ExtensionStore {
        let work_dir = self.wasm_host.work_dir.clone();
        let extensions_dir = self.installed_dir.clone();
        let index_path = self.index_path.clone();
-        let extension_api = self.registration_hooks.clone();
+        let proxy = self.proxy.clone();
        cx.background_executor().spawn(async move {
            let start_time = Instant::now();
            let mut index = ExtensionIndex::default();
@@ -1314,7 +1262,7 @@ impl ExtensionStore {
                        fs.clone(),
                        extension_dir,
                        &mut index,
-                        extension_api.clone(),
+                        proxy.clone(),
                    )
                    .await
                    .log_err();
@@ -1337,7 +1285,7 @@ impl ExtensionStore {
        fs: Arc<dyn Fs>,
        extension_dir: PathBuf,
        index: &mut ExtensionIndex,
-        extension_api: Arc<dyn ExtensionRegistrationHooks>,
+        proxy: Arc<ExtensionHostProxy>,
    ) -> Result<()> {
        let mut extension_manifest = ExtensionManifest::load(fs.clone(), &extension_dir).await?;
        let extension_id = extension_manifest.id.clone();
@@ -1389,7 +1337,7 @@ impl ExtensionStore {
                    continue;
                };

-                let Some(theme_families) = extension_api
+                let Some(theme_families) = proxy
                    .list_theme_names(theme_path.clone(), fs.clone())
                    .await
                    .log_err()
@@ -1432,6 +1380,144 @@ impl ExtensionStore {

        Ok(())
    }
+
+    fn prepare_remote_extension(
+        &mut self,
+        extension_id: Arc<str>,
+        tmp_dir: PathBuf,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<()>> {
+        let src_dir = self.extensions_dir().join(extension_id.as_ref());
+        let Some(loaded_extension) = self.extension_index.extensions.get(&extension_id).cloned()
+        else {
+            return Task::ready(Err(anyhow!("extension no longer installed")));
+        };
+        let fs = self.fs.clone();
+        cx.background_executor().spawn(async move {
+            for well_known_path in ["extension.toml", "extension.json", "extension.wasm"] {
+                if fs.is_file(&src_dir.join(well_known_path)).await {
+                    fs.copy_file(
+                        &src_dir.join(well_known_path),
+                        &tmp_dir.join(well_known_path),
+                        fs::CopyOptions::default(),
+                    )
+                    .await?
+                }
+            }
+
+            for language_path in loaded_extension.manifest.languages.iter() {
+                if fs
+                    .is_file(&src_dir.join(language_path).join("config.toml"))
+                    .await
+                {
+                    fs.create_dir(&tmp_dir.join(language_path)).await?;
+                    fs.copy_file(
+                        &src_dir.join(language_path).join("config.toml"),
+                        &tmp_dir.join(language_path).join("config.toml"),
+                        fs::CopyOptions::default(),
+                    )
+                    .await?
+                }
+            }
+
+            Ok(())
+        })
+    }
+
+    async fn sync_extensions_over_ssh(
+        this: &WeakModel<Self>,
+        client: WeakModel<SshRemoteClient>,
+        cx: &mut AsyncAppContext,
+    ) -> Result<()> {
+        let extensions = this.update(cx, |this, _cx| {
+            this.extension_index
+                .extensions
+                .iter()
+                .filter_map(|(id, entry)| {
+                    if entry.manifest.language_servers.is_empty() {
+                        return None;
+                    }
+                    Some(proto::Extension {
+                        id: id.to_string(),
+                        version: entry.manifest.version.to_string(),
+                        dev: entry.dev,
+                    })
+                })
+                .collect()
+        })?;
+
+        let response = client
+            .update(cx, |client, _cx| {
+                client
+                    .proto_client()
+                    .request(proto::SyncExtensions { extensions })
+            })?
+            .await?;
+
+        for missing_extension in response.missing_extensions.into_iter() {
+            let tmp_dir = tempfile::tempdir()?;
+            this.update(cx, |this, cx| {
+                this.prepare_remote_extension(
+                    missing_extension.id.clone().into(),
+                    tmp_dir.path().to_owned(),
+                    cx,
+                )
+            })?
+            .await?;
+            let dest_dir = PathBuf::from(&response.tmp_dir).join(missing_extension.clone().id);
+            log::info!("Uploading extension {}", missing_extension.clone().id);
+
+            client
+                .update(cx, |client, cx| {
+                    client.upload_directory(tmp_dir.path().to_owned(), dest_dir.clone(), cx)
+                })?
+                .await?;
+
+            client
+                .update(cx, |client, _cx| {
+                    client.proto_client().request(proto::InstallExtension {
+                        tmp_dir: dest_dir.to_string_lossy().to_string(),
+                        extension: Some(missing_extension),
+                    })
+                })?
+                .await?;
+        }
+
+        anyhow::Ok(())
+    }
+
+    pub async fn update_ssh_clients(
+        this: &WeakModel<Self>,
+        cx: &mut AsyncAppContext,
+    ) -> Result<()> {
+        let clients = this.update(cx, |this, _cx| {
+            this.ssh_clients.retain(|_k, v| v.upgrade().is_some());
+            this.ssh_clients.values().cloned().collect::<Vec<_>>()
+        })?;
+
+        for client in clients {
+            Self::sync_extensions_over_ssh(&this, client, cx)
+                .await
+                .log_err();
+        }
+
+        anyhow::Ok(())
+    }
+
+    pub fn register_ssh_client(
+        &mut self,
+        client: Model<SshRemoteClient>,
+        cx: &mut ModelContext<Self>,
+    ) {
+        let connection_options = client.read(cx).connection_options();
+        if self.ssh_clients.contains_key(&connection_options.ssh_url()) {
+            return;
+        }
+
+        self.ssh_clients
+            .insert(connection_options.ssh_url(), client.downgrade());
+        self.ssh_registered_tx.unbounded_send(()).ok();
+    }
 }

 fn load_plugin_queries(root_path: &Path) -> LanguageQueries {
--- a/crates/extension_host/src/extension_lsp_adapter.rs
+++ b/crates/extension_host/src/extension_lsp_adapter.rs
@@ -1,627 +0,0 @@
-use crate::wasm_host::{
-    wit::{self, LanguageServerConfig},
-    WasmExtension, WasmHost,
-};
-use anyhow::{anyhow, Context, Result};
-use async_trait::async_trait;
-use collections::HashMap;
-use extension::WorktreeDelegate;
-use futures::{Future, FutureExt};
-use gpui::AsyncAppContext;
-use language::{
-    CodeLabel, HighlightId, Language, LanguageToolchainStore, LspAdapter, LspAdapterDelegate,
-};
-use lsp::{CodeActionKind, LanguageServerBinary, LanguageServerBinaryOptions, LanguageServerName};
-use serde::Serialize;
-use serde_json::Value;
-use std::ops::Range;
-use std::{any::Any, path::PathBuf, pin::Pin, sync::Arc};
-use util::{maybe, ResultExt};
-use wasmtime_wasi::WasiView as _;
-
-/// An adapter that allows an [`LspAdapterDelegate`] to be used as a [`WorktreeDelegate`].
-pub struct WorktreeDelegateAdapter(pub Arc<dyn LspAdapterDelegate>);
-
-#[async_trait]
-impl WorktreeDelegate for WorktreeDelegateAdapter {
-    fn id(&self) -> u64 {
-        self.0.worktree_id().to_proto()
-    }
-
-    fn root_path(&self) -> String {
-        self.0.worktree_root_path().to_string_lossy().to_string()
-    }
-
-    async fn read_text_file(&self, path: PathBuf) -> Result<String> {
-        self.0.read_text_file(path).await
-    }
-
-    async fn which(&self, binary_name: String) -> Option<String> {
-        self.0
-            .which(binary_name.as_ref())
-            .await
-            .map(|path| path.to_string_lossy().to_string())
-    }
-
-    async fn shell_env(&self) -> Vec<(String, String)> {
-        self.0.shell_env().await.into_iter().collect()
-    }
-}
-
-pub struct ExtensionLspAdapter {
-    pub(crate) extension: WasmExtension,
-    pub(crate) language_server_id: LanguageServerName,
-    pub(crate) config: LanguageServerConfig,
-    pub(crate) host: Arc<WasmHost>,
-}
-
-#[async_trait(?Send)]
-impl LspAdapter for ExtensionLspAdapter {
-    fn name(&self) -> LanguageServerName {
-        LanguageServerName(self.config.name.clone().into())
-    }
-
-    fn get_language_server_command<'a>(
-        self: Arc<Self>,
-        delegate: Arc<dyn LspAdapterDelegate>,
-        _: LanguageServerBinaryOptions,
-        _: futures::lock::MutexGuard<'a, Option<LanguageServerBinary>>,
-        _: &'a mut AsyncAppContext,
-    ) -> Pin<Box<dyn 'a + Future<Output = Result<LanguageServerBinary>>>> {
-        async move {
-            let command = self
-                .extension
-                .call({
-                    let this = self.clone();
-                    |extension, store| {
-                        async move {
-                            let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
-                            let resource = store.data_mut().table().push(delegate)?;
-                            let command = extension
-                                .call_language_server_command(
-                                    store,
-                                    &this.language_server_id,
-                                    &this.config,
-                                    resource,
-                                )
-                                .await?
-                                .map_err(|e| anyhow!("{}", e))?;
-                            anyhow::Ok(command)
-                        }
-                        .boxed()
-                    }
-                })
-                .await?;
-
-            let path = self
-                .host
-                .path_from_extension(&self.extension.manifest.id, command.command.as_ref());
-
-            // TODO: This should now be done via the `zed::make_file_executable` function in
-            // Zed extension API, but we're leaving these existing usages in place temporarily
-            // to avoid any compatibility issues between Zed and the extension versions.
-            //
-            // We can remove once the following extension versions no longer see any use:
-            // - toml@0.0.2
-            // - zig@0.0.1
-            if ["toml", "zig"].contains(&self.extension.manifest.id.as_ref())
-                && path.starts_with(&self.host.work_dir)
-            {
-                #[cfg(not(windows))]
-                {
-                    use std::fs::{self, Permissions};
-                    use std::os::unix::fs::PermissionsExt;
-
-                    fs::set_permissions(&path, Permissions::from_mode(0o755))
-                        .context("failed to set file permissions")?;
-                }
-            }
-
-            Ok(LanguageServerBinary {
-                path,
-                arguments: command.args.into_iter().map(|arg| arg.into()).collect(),
-                env: Some(command.env.into_iter().collect()),
-            })
-        }
-        .boxed_local()
-    }
-
-    async fn fetch_latest_server_version(
-        &self,
-        _: &dyn LspAdapterDelegate,
-    ) -> Result<Box<dyn 'static + Send + Any>> {
-        unreachable!("get_language_server_command is overridden")
-    }
-
-    async fn fetch_server_binary(
-        &self,
-        _: Box<dyn 'static + Send + Any>,
-        _: PathBuf,
-        _: &dyn LspAdapterDelegate,
-    ) -> Result<LanguageServerBinary> {
-        unreachable!("get_language_server_command is overridden")
-    }
-
-    async fn cached_server_binary(
-        &self,
-        _: PathBuf,
-        _: &dyn LspAdapterDelegate,
-    ) -> Option<LanguageServerBinary> {
-        unreachable!("get_language_server_command is overridden")
-    }
-
-    fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> {
-        let code_action_kinds = self
-            .extension
-            .manifest
-            .language_servers
-            .get(&self.language_server_id)
-            .and_then(|server| server.code_action_kinds.clone());
-
-        code_action_kinds.or(Some(vec![
-            CodeActionKind::EMPTY,
-            CodeActionKind::QUICKFIX,
-            CodeActionKind::REFACTOR,
-            CodeActionKind::REFACTOR_EXTRACT,
-            CodeActionKind::SOURCE,
-        ]))
-    }
-
-    fn language_ids(&self) -> HashMap<String, String> {
-        // TODO: The language IDs can be provided via the language server options
-        // in `extension.toml now but we're leaving these existing usages in place temporarily
-        // to avoid any compatibility issues between Zed and the extension versions.
-        //
-        // We can remove once the following extension versions no longer see any use:
-        // - php@0.0.1
-        if self.extension.manifest.id.as_ref() == "php" {
-            return HashMap::from_iter([("PHP".into(), "php".into())]);
-        }
-
-        self.extension
-            .manifest
-            .language_servers
-            .get(&LanguageServerName(self.config.name.clone().into()))
-            .map(|server| server.language_ids.clone())
-            .unwrap_or_default()
-    }
-
-    async fn initialization_options(
-        self: Arc<Self>,
-        delegate: &Arc<dyn LspAdapterDelegate>,
-    ) -> Result<Option<serde_json::Value>> {
-        let delegate = delegate.clone();
-        let json_options = self
-            .extension
-            .call({
-                let this = self.clone();
-                |extension, store| {
-                    async move {
-                        let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
-                        let resource = store.data_mut().table().push(delegate)?;
-                        let options = extension
-                            .call_language_server_initialization_options(
-                                store,
-                                &this.language_server_id,
-                                &this.config,
-                                resource,
-                            )
-                            .await?
-                            .map_err(|e| anyhow!("{}", e))?;
-                        anyhow::Ok(options)
-                    }
-                    .boxed()
-                }
-            })
-            .await?;
-        Ok(if let Some(json_options) = json_options {
-            serde_json::from_str(&json_options).with_context(|| {
-                format!("failed to parse initialization_options from extension: {json_options}")
-            })?
-        } else {
-            None
-        })
-    }
-
-    async fn workspace_configuration(
-        self: Arc<Self>,
-        delegate: &Arc<dyn LspAdapterDelegate>,
-        _: Arc<dyn LanguageToolchainStore>,
-        _cx: &mut AsyncAppContext,
-    ) -> Result<Value> {
-        let delegate = delegate.clone();
-        let json_options: Option<String> = self
-            .extension
-            .call({
-                let this = self.clone();
-                |extension, store| {
-                    async move {
-                        let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
-                        let resource = store.data_mut().table().push(delegate)?;
-                        let options = extension
-                            .call_language_server_workspace_configuration(
-                                store,
-                                &this.language_server_id,
-                                resource,
-                            )
-                            .await?
-                            .map_err(|e| anyhow!("{}", e))?;
-                        anyhow::Ok(options)
-                    }
-                    .boxed()
-                }
-            })
-            .await?;
-        Ok(if let Some(json_options) = json_options {
-            serde_json::from_str(&json_options).with_context(|| {
-                format!("failed to parse initialization_options from extension: {json_options}")
-            })?
-        } else {
-            serde_json::json!({})
-        })
-    }
-
-    async fn labels_for_completions(
-        self: Arc<Self>,
-        completions: &[lsp::CompletionItem],
-        language: &Arc<Language>,
-    ) -> Result<Vec<Option<CodeLabel>>> {
-        let completions = completions
-            .iter()
-            .map(|completion| wit::Completion::from(completion.clone()))
-            .collect::<Vec<_>>();
-
-        let labels = self
-            .extension
-            .call({
-                let this = self.clone();
-                |extension, store| {
-                    async move {
-                        extension
-                            .call_labels_for_completions(
-                                store,
-                                &this.language_server_id,
-                                completions,
-                            )
-                            .await?
-                            .map_err(|e| anyhow!("{}", e))
-                    }
-                    .boxed()
-                }
-            })
-            .await?;
-
-        Ok(labels_from_wit(labels, language))
-    }
-
-    async fn labels_for_symbols(
-        self: Arc<Self>,
-        symbols: &[(String, lsp::SymbolKind)],
-        language: &Arc<Language>,
-    ) -> Result<Vec<Option<CodeLabel>>> {
-        let symbols = symbols
-            .iter()
-            .cloned()
-            .map(|(name, kind)| wit::Symbol {
-                name,
-                kind: kind.into(),
-            })
-            .collect::<Vec<_>>();
-
-        let labels = self
-            .extension
-            .call({
-                let this = self.clone();
-                |extension, store| {
-                    async move {
-                        extension
-                            .call_labels_for_symbols(store, &this.language_server_id, symbols)
-                            .await?
-                            .map_err(|e| anyhow!("{}", e))
-                    }
-                    .boxed()
-                }
-            })
-            .await?;
-
-        Ok(labels_from_wit(labels, language))
-    }
-}
-
-fn labels_from_wit(
-    labels: Vec<Option<wit::CodeLabel>>,
-    language: &Arc<Language>,
-) -> Vec<Option<CodeLabel>> {
-    labels
-        .into_iter()
-        .map(|label| {
-            let label = label?;
-            let runs = if label.code.is_empty() {
-                Vec::new()
-            } else {
-                language.highlight_text(&label.code.as_str().into(), 0..label.code.len())
-            };
-            build_code_label(&label, &runs, language)
-        })
-        .collect()
-}
-
-fn build_code_label(
-    label: &wit::CodeLabel,
-    parsed_runs: &[(Range<usize>, HighlightId)],
-    language: &Arc<Language>,
-) -> Option<CodeLabel> {
-    let mut text = String::new();
-    let mut runs = vec![];
-
-    for span in &label.spans {
-        match span {
-            wit::CodeLabelSpan::CodeRange(range) => {
-                let range = Range::from(*range);
-                let code_span = &label.code.get(range.clone())?;
-                let mut input_ix = range.start;
-                let mut output_ix = text.len();
-                for (run_range, id) in parsed_runs {
-                    if run_range.start >= range.end {
-                        break;
-                    }
-                    if run_range.end <= input_ix {
-                        continue;
-                    }
-
-                    if run_range.start > input_ix {
-                        let len = run_range.start - input_ix;
-                        output_ix += len;
-                        input_ix += len;
-                    }
-
-                    let len = range.end.min(run_range.end) - input_ix;
-                    runs.push((output_ix..output_ix + len, *id));
-                    output_ix += len;
-                    input_ix += len;
-                }
-
-                text.push_str(code_span);
-            }
-            wit::CodeLabelSpan::Literal(span) => {
-                let highlight_id = language
-                    .grammar()
-                    .zip(span.highlight_name.as_ref())
-                    .and_then(|(grammar, highlight_name)| {
-                        grammar.highlight_id_for_name(highlight_name)
-                    })
-                    .unwrap_or_default();
-                let ix = text.len();
-                runs.push((ix..ix + span.text.len(), highlight_id));
-                text.push_str(&span.text);
-            }
-        }
-    }
-
-    let filter_range = Range::from(label.filter_range);
-    text.get(filter_range.clone())?;
-    Some(CodeLabel {
-        text,
-        runs,
-        filter_range,
-    })
-}
-
-impl From<wit::Range> for Range<usize> {
-    fn from(range: wit::Range) -> Self {
-        let start = range.start as usize;
-        let end = range.end as usize;
-        start..end
-    }
-}
-
-impl From<lsp::CompletionItem> for wit::Completion {
-    fn from(value: lsp::CompletionItem) -> Self {
-        Self {
-            label: value.label,
-            label_details: value.label_details.map(Into::into),
-            detail: value.detail,
-            kind: value.kind.map(Into::into),
-            insert_text_format: value.insert_text_format.map(Into::into),
-        }
-    }
-}
-
-impl From<lsp::CompletionItemLabelDetails> for wit::CompletionLabelDetails {
-    fn from(value: lsp::CompletionItemLabelDetails) -> Self {
-        Self {
-            detail: value.detail,
-            description: value.description,
-        }
-    }
-}
-
-impl From<lsp::CompletionItemKind> for wit::CompletionKind {
-    fn from(value: lsp::CompletionItemKind) -> Self {
-        match value {
-            lsp::CompletionItemKind::TEXT => Self::Text,
-            lsp::CompletionItemKind::METHOD => Self::Method,
-            lsp::CompletionItemKind::FUNCTION => Self::Function,
-            lsp::CompletionItemKind::CONSTRUCTOR => Self::Constructor,
-            lsp::CompletionItemKind::FIELD => Self::Field,
-            lsp::CompletionItemKind::VARIABLE => Self::Variable,
-            lsp::CompletionItemKind::CLASS => Self::Class,
-            lsp::CompletionItemKind::INTERFACE => Self::Interface,
-            lsp::CompletionItemKind::MODULE => Self::Module,
-            lsp::CompletionItemKind::PROPERTY => Self::Property,
-            lsp::CompletionItemKind::UNIT => Self::Unit,
-            lsp::CompletionItemKind::VALUE => Self::Value,
-            lsp::CompletionItemKind::ENUM => Self::Enum,
-            lsp::CompletionItemKind::KEYWORD => Self::Keyword,
-            lsp::CompletionItemKind::SNIPPET => Self::Snippet,
-            lsp::CompletionItemKind::COLOR => Self::Color,
-            lsp::CompletionItemKind::FILE => Self::File,
-            lsp::CompletionItemKind::REFERENCE => Self::Reference,
-            lsp::CompletionItemKind::FOLDER => Self::Folder,
-            lsp::CompletionItemKind::ENUM_MEMBER => Self::EnumMember,
-            lsp::CompletionItemKind::CONSTANT => Self::Constant,
-            lsp::CompletionItemKind::STRUCT => Self::Struct,
-            lsp::CompletionItemKind::EVENT => Self::Event,
-            lsp::CompletionItemKind::OPERATOR => Self::Operator,
-            lsp::CompletionItemKind::TYPE_PARAMETER => Self::TypeParameter,
-            _ => Self::Other(extract_int(value)),
-        }
-    }
-}
-
-impl From<lsp::InsertTextFormat> for wit::InsertTextFormat {
-    fn from(value: lsp::InsertTextFormat) -> Self {
-        match value {
-            lsp::InsertTextFormat::PLAIN_TEXT => Self::PlainText,
-            lsp::InsertTextFormat::SNIPPET => Self::Snippet,
-            _ => Self::Other(extract_int(value)),
-        }
-    }
-}
-
-impl From<lsp::SymbolKind> for wit::SymbolKind {
-    fn from(value: lsp::SymbolKind) -> Self {
-        match value {
-            lsp::SymbolKind::FILE => Self::File,
-            lsp::SymbolKind::MODULE => Self::Module,
-            lsp::SymbolKind::NAMESPACE => Self::Namespace,
-            lsp::SymbolKind::PACKAGE => Self::Package,
-            lsp::SymbolKind::CLASS => Self::Class,
-            lsp::SymbolKind::METHOD => Self::Method,
-            lsp::SymbolKind::PROPERTY => Self::Property,
-            lsp::SymbolKind::FIELD => Self::Field,
-            lsp::SymbolKind::CONSTRUCTOR => Self::Constructor,
-            lsp::SymbolKind::ENUM => Self::Enum,
-            lsp::SymbolKind::INTERFACE => Self::Interface,
-            lsp::SymbolKind::FUNCTION => Self::Function,
-            lsp::SymbolKind::VARIABLE => Self::Variable,
-            lsp::SymbolKind::CONSTANT => Self::Constant,
-            lsp::SymbolKind::STRING => Self::String,
-            lsp::SymbolKind::NUMBER => Self::Number,
-            lsp::SymbolKind::BOOLEAN => Self::Boolean,
-            lsp::SymbolKind::ARRAY => Self::Array,
-            lsp::SymbolKind::OBJECT => Self::Object,
-            lsp::SymbolKind::KEY => Self::Key,
-            lsp::SymbolKind::NULL => Self::Null,
-            lsp::SymbolKind::ENUM_MEMBER => Self::EnumMember,
-            lsp::SymbolKind::STRUCT => Self::Struct,
-            lsp::SymbolKind::EVENT => Self::Event,
-            lsp::SymbolKind::OPERATOR => Self::Operator,
-            lsp::SymbolKind::TYPE_PARAMETER => Self::TypeParameter,
-            _ => Self::Other(extract_int(value)),
-        }
-    }
-}
-
-fn extract_int<T: Serialize>(value: T) -> i32 {
-    maybe!({
-        let kind = serde_json::to_value(&value)?;
-        serde_json::from_value(kind)
-    })
-    .log_err()
-    .unwrap_or(-1)
-}
-
-#[test]
-fn test_build_code_label() {
-    use util::test::marked_text_ranges;
-
-    let (code, code_ranges) = marked_text_ranges(
-        "«const» «a»: «fn»(«Bcd»(«Efgh»)) -> «Ijklm» = pqrs.tuv",
-        false,
-    );
-    let code_runs = code_ranges
-        .into_iter()
-        .map(|range| (range, HighlightId(0)))
-        .collect::<Vec<_>>();
-
-    let label = build_code_label(
-        &wit::CodeLabel {
-            spans: vec![
-                wit::CodeLabelSpan::CodeRange(wit::Range {
-                    start: code.find("pqrs").unwrap() as u32,
-                    end: code.len() as u32,
-                }),
-                wit::CodeLabelSpan::CodeRange(wit::Range {
-                    start: code.find(": fn").unwrap() as u32,
-                    end: code.find(" = ").unwrap() as u32,
-                }),
-            ],
-            filter_range: wit::Range {
-                start: 0,
-                end: "pqrs.tuv".len() as u32,
-            },
-            code,
-        },
-        &code_runs,
-        &language::PLAIN_TEXT,
-    )
-    .unwrap();
-
-    let (label_text, label_ranges) =
-        marked_text_ranges("pqrs.tuv: «fn»(«Bcd»(«Efgh»)) -> «Ijklm»", false);
-    let label_runs = label_ranges
-        .into_iter()
-        .map(|range| (range, HighlightId(0)))
-        .collect::<Vec<_>>();
-
-    assert_eq!(
-        label,
-        CodeLabel {
-            text: label_text,
-            runs: label_runs,
-            filter_range: label.filter_range.clone()
-        }
-    )
-}
-
-#[test]
-fn test_build_code_label_with_invalid_ranges() {
-    use util::test::marked_text_ranges;
-
-    let (code, code_ranges) = marked_text_ranges("const «a»: «B» = '🏀'", false);
-    let code_runs = code_ranges
-        .into_iter()
-        .map(|range| (range, HighlightId(0)))
-        .collect::<Vec<_>>();
-
-    // A span uses a code range that is invalid because it starts inside of
-    // a multi-byte character.
-    let label = build_code_label(
-        &wit::CodeLabel {
-            spans: vec![
-                wit::CodeLabelSpan::CodeRange(wit::Range {
-                    start: code.find('B').unwrap() as u32,
-                    end: code.find(" = ").unwrap() as u32,
-                }),
-                wit::CodeLabelSpan::CodeRange(wit::Range {
-                    start: code.find('🏀').unwrap() as u32 + 1,
-                    end: code.len() as u32,
-                }),
-            ],
-            filter_range: wit::Range {
-                start: 0,
-                end: "B".len() as u32,
-            },
-            code,
-        },
-        &code_runs,
-        &language::PLAIN_TEXT,
-    );
-    assert!(label.is_none());
-
-    // Filter range extends beyond actual text
-    let label = build_code_label(
-        &wit::CodeLabel {
-            spans: vec![wit::CodeLabelSpan::Literal(wit::CodeLabelSpanLiteral {
-                text: "abc".into(),
-                highlight_name: Some("type".into()),
-            })],
-            filter_range: wit::Range { start: 0, end: 5 },
-            code: String::new(),
-        },
-        &code_runs,
-        &language::PLAIN_TEXT,
-    );
-    assert!(label.is_none());
-}
--- a/crates/extension_host/src/extension_store_test.rs
+++ b/crates/extension_host/src/extension_store_test.rs
@@ -1,19 +1,15 @@
-use assistant_slash_command::SlashCommandRegistry;
+use crate::{
+    Event, ExtensionIndex, ExtensionIndexEntry, ExtensionIndexLanguageEntry,
+    ExtensionIndexThemeEntry, ExtensionManifest, ExtensionSettings, ExtensionStore,
+    GrammarManifestEntry, SchemaVersion, RELOAD_DEBOUNCE_DURATION,
+};
 use async_compression::futures::bufread::GzipEncoder;
 use collections::BTreeMap;
-use context_servers::ContextServerFactoryRegistry;
-use extension_host::ExtensionSettings;
-use extension_host::SchemaVersion;
-use extension_host::{
-    Event, ExtensionIndex, ExtensionIndexEntry, ExtensionIndexLanguageEntry,
-    ExtensionIndexThemeEntry, ExtensionManifest, ExtensionStore, GrammarManifestEntry,
-    RELOAD_DEBOUNCE_DURATION,
-};
+use extension::ExtensionHostProxy;
 use fs::{FakeFs, Fs, RealFs};
 use futures::{io::BufReader, AsyncReadExt, StreamExt};
 use gpui::{Context, SemanticVersion, TestAppContext};
 use http_client::{FakeHttpClient, Response};
-use indexed_docs::IndexedDocsRegistry;
 use language::{LanguageMatcher, LanguageRegistry, LanguageServerBinaryStatus};
 use lsp::LanguageServerName;
 use node_runtime::NodeRuntime;
@@ -23,7 +19,6 @@ use release_channel::AppVersion;
 use reqwest_client::ReqwestClient;
 use serde_json::json;
 use settings::{Settings as _, SettingsStore};
-use snippet_provider::SnippetRegistry;
 use std::{
    ffi::OsString,
    path::{Path, PathBuf},
@@ -263,29 +258,18 @@ async fn test_extension_store(cx: &mut TestAppContext) {
        .collect(),
    };

-    let language_registry = Arc::new(LanguageRegistry::test(cx.executor()));
+    let proxy = Arc::new(ExtensionHostProxy::new());
    let theme_registry = Arc::new(ThemeRegistry::new(Box::new(())));
-    let slash_command_registry = SlashCommandRegistry::new();
-    let indexed_docs_registry = Arc::new(IndexedDocsRegistry::new(cx.executor()));
-    let snippet_registry = Arc::new(SnippetRegistry::new());
-    let context_server_factory_registry = cx.new_model(|_| ContextServerFactoryRegistry::new());
+    theme_extension::init(proxy.clone(), theme_registry.clone(), cx.executor());
+    let language_registry = Arc::new(LanguageRegistry::test(cx.executor()));
+    language_extension::init(proxy.clone(), language_registry.clone());
    let node_runtime = NodeRuntime::unavailable();

    let store = cx.new_model(|cx| {
-        let extension_registration_hooks = crate::ConcreteExtensionRegistrationHooks::new(
-            theme_registry.clone(),
-            slash_command_registry.clone(),
-            indexed_docs_registry.clone(),
-            snippet_registry.clone(),
-            language_registry.clone(),
-            context_server_factory_registry.clone(),
-            cx,
-        );
-
        ExtensionStore::new(
            PathBuf::from("/the-extension-dir"),
            None,
-            extension_registration_hooks,
+            proxy.clone(),
            fs.clone(),
            http_client.clone(),
            http_client.clone(),
@@ -407,20 +391,10 @@ async fn test_extension_store(cx: &mut TestAppContext) {
    // Create new extension store, as if Zed were restarting.
    drop(store);
    let store = cx.new_model(|cx| {
-        let extension_api = crate::ConcreteExtensionRegistrationHooks::new(
-            theme_registry.clone(),
-            slash_command_registry,
-            indexed_docs_registry,
-            snippet_registry,
-            language_registry.clone(),
-            context_server_factory_registry.clone(),
-            cx,
-        );
-
        ExtensionStore::new(
            PathBuf::from("/the-extension-dir"),
            None,
-            extension_api,
+            proxy,
            fs.clone(),
            http_client.clone(),
            http_client.clone(),
@@ -503,12 +477,11 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {

    let project = Project::test(fs.clone(), [project_dir.as_path()], cx).await;

-    let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
+    let proxy = Arc::new(ExtensionHostProxy::new());
    let theme_registry = Arc::new(ThemeRegistry::new(Box::new(())));
-    let slash_command_registry = SlashCommandRegistry::new();
-    let indexed_docs_registry = Arc::new(IndexedDocsRegistry::new(cx.executor()));
-    let snippet_registry = Arc::new(SnippetRegistry::new());
-    let context_server_factory_registry = cx.new_model(|_| ContextServerFactoryRegistry::new());
+    theme_extension::init(proxy.clone(), theme_registry.clone(), cx.executor());
+    let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
+    language_extension::init(proxy.clone(), language_registry.clone());
    let node_runtime = NodeRuntime::unavailable();

    let mut status_updates = language_registry.language_server_binary_statuses();
@@ -599,19 +572,10 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
        Arc::new(ReqwestClient::user_agent(&user_agent).expect("Could not create HTTP client"));

    let extension_store = cx.new_model(|cx| {
-        let extension_api = crate::ConcreteExtensionRegistrationHooks::new(
-            theme_registry.clone(),
-            slash_command_registry,
-            indexed_docs_registry,
-            snippet_registry,
-            language_registry.clone(),
-            context_server_factory_registry.clone(),
-            cx,
-        );
        ExtensionStore::new(
            extensions_dir.clone(),
            Some(cache_dir),
-            extension_api,
+            proxy,
            fs.clone(),
            extension_client.clone(),
            builder_client,
@@ -626,7 +590,7 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
    let executor = cx.executor();
    let _task = cx.executor().spawn(async move {
        while let Some(event) = events.next().await {
-            if let extension_host::Event::StartedReloading = event {
+            if let Event::StartedReloading = event {
                executor.advance_clock(RELOAD_DEBOUNCE_DURATION);
            }
        }
--- a/crates/extension_host/src/headless_host.rs
+++ b/crates/extension_host/src/headless_host.rs
@@ -0,0 +1,319 @@
+use std::{path::PathBuf, sync::Arc};
+
+use anyhow::{anyhow, Context as _, Result};
+use client::{proto, TypedEnvelope};
+use collections::{HashMap, HashSet};
+use extension::{
+    Extension, ExtensionHostProxy, ExtensionLanguageProxy, ExtensionLanguageServerProxy,
+    ExtensionManifest,
+};
+use fs::{Fs, RemoveOptions, RenameOptions};
+use gpui::{AppContext, AsyncAppContext, Context, Model, ModelContext, Task, WeakModel};
+use http_client::HttpClient;
+use language::{LanguageConfig, LanguageName, LanguageQueries, LoadedLanguage};
+use lsp::LanguageServerName;
+use node_runtime::NodeRuntime;
+
+use crate::wasm_host::{WasmExtension, WasmHost};
+
+#[derive(Clone, Debug)]
+pub struct ExtensionVersion {
+    pub id: String,
+    pub version: String,
+    pub dev: bool,
+}
+
+pub struct HeadlessExtensionStore {
+    pub fs: Arc<dyn Fs>,
+    pub extension_dir: PathBuf,
+    pub proxy: Arc<ExtensionHostProxy>,
+    pub wasm_host: Arc<WasmHost>,
+    pub loaded_extensions: HashMap<Arc<str>, Arc<str>>,
+    pub loaded_languages: HashMap<Arc<str>, Vec<LanguageName>>,
+    pub loaded_language_servers: HashMap<Arc<str>, Vec<(LanguageServerName, LanguageName)>>,
+}
+
+impl HeadlessExtensionStore {
+    pub fn new(
+        fs: Arc<dyn Fs>,
+        http_client: Arc<dyn HttpClient>,
+        extension_dir: PathBuf,
+        extension_host_proxy: Arc<ExtensionHostProxy>,
+        node_runtime: NodeRuntime,
+        cx: &mut AppContext,
+    ) -> Model<Self> {
+        cx.new_model(|cx| Self {
+            fs: fs.clone(),
+            wasm_host: WasmHost::new(
+                fs.clone(),
+                http_client.clone(),
+                node_runtime,
+                extension_host_proxy.clone(),
+                extension_dir.join("work"),
+                cx,
+            ),
+            extension_dir,
+            proxy: extension_host_proxy,
+            loaded_extensions: Default::default(),
+            loaded_languages: Default::default(),
+            loaded_language_servers: Default::default(),
+        })
+    }
+
+    pub fn sync_extensions(
+        &mut self,
+        extensions: Vec<ExtensionVersion>,
+        cx: &ModelContext<Self>,
+    ) -> Task<Result<Vec<ExtensionVersion>>> {
+        let on_client = HashSet::from_iter(extensions.iter().map(|e| e.id.as_str()));
+        let to_remove: Vec<Arc<str>> = self
+            .loaded_extensions
+            .keys()
+            .filter(|id| !on_client.contains(id.as_ref()))
+            .cloned()
+            .collect();
+        let to_load: Vec<ExtensionVersion> = extensions
+            .into_iter()
+            .filter(|e| {
+                if e.dev {
+                    return true;
+                }
+                !self
+                    .loaded_extensions
+                    .get(e.id.as_str())
+                    .is_some_and(|loaded| loaded.as_ref() == e.version.as_str())
+            })
+            .collect();
+
+        cx.spawn(|this, mut cx| async move {
+            let mut missing = Vec::new();
+
+            for extension_id in to_remove {
+                log::info!("removing extension: {}", extension_id);
+                this.update(&mut cx, |this, cx| {
+                    this.uninstall_extension(&extension_id, cx)
+                })?
+                .await?;
+            }
+
+            for extension in to_load {
+                if let Err(e) = Self::load_extension(this.clone(), extension.clone(), &mut cx).await
+                {
+                    log::info!("failed to load extension: {}, {:?}", extension.id, e);
+                    missing.push(extension)
+                } else if extension.dev {
+                    missing.push(extension)
+                }
+            }
+
+            Ok(missing)
+        })
+    }
+
+    pub async fn load_extension(
+        this: WeakModel<Self>,
+        extension: ExtensionVersion,
+        cx: &mut AsyncAppContext,
+    ) -> Result<()> {
+        let (fs, wasm_host, extension_dir) = this.update(cx, |this, _cx| {
+            this.loaded_extensions.insert(
+                extension.id.clone().into(),
+                extension.version.clone().into(),
+            );
+            (
+                this.fs.clone(),
+                this.wasm_host.clone(),
+                this.extension_dir.join(&extension.id),
+            )
+        })?;
+
+        let manifest = Arc::new(ExtensionManifest::load(fs.clone(), &extension_dir).await?);
+
+        debug_assert!(!manifest.languages.is_empty() || !manifest.language_servers.is_empty());
+
+        if manifest.version.as_ref() != extension.version.as_str() {
+            anyhow::bail!(
+                "mismatched versions: ({}) != ({})",
+                manifest.version,
+                extension.version
+            )
+        }
+
+        for language_path in &manifest.languages {
+            let language_path = extension_dir.join(language_path);
+            let config = fs.load(&language_path.join("config.toml")).await?;
+            let mut config = ::toml::from_str::<LanguageConfig>(&config)?;
+
+            this.update(cx, |this, _cx| {
+                this.loaded_languages
+                    .entry(manifest.id.clone())
+                    .or_default()
+                    .push(config.name.clone());
+
+                config.grammar = None;
+
+                this.proxy.register_language(
+                    config.name.clone(),
+                    None,
+                    config.matcher.clone(),
+                    Arc::new(move || {
+                        Ok(LoadedLanguage {
+                            config: config.clone(),
+                            queries: LanguageQueries::default(),
+                            context_provider: None,
+                            toolchain_provider: None,
+                        })
+                    }),
+                );
+            })?;
+        }
+
+        if manifest.language_servers.is_empty() {
+            return Ok(());
+        }
+
+        let wasm_extension: Arc<dyn Extension> =
+            Arc::new(WasmExtension::load(extension_dir, &manifest, wasm_host.clone(), &cx).await?);
+
+        for (language_server_id, language_server_config) in &manifest.language_servers {
+            for language in language_server_config.languages() {
+                this.update(cx, |this, _cx| {
+                    this.loaded_language_servers
+                        .entry(manifest.id.clone())
+                        .or_default()
+                        .push((language_server_id.clone(), language.clone()));
+                    this.proxy.register_language_server(
+                        wasm_extension.clone(),
+                        language_server_id.clone(),
+                        language.clone(),
+                    );
+                })?;
+            }
+        }
+
+        Ok(())
+    }
+
+    fn uninstall_extension(
+        &mut self,
+        extension_id: &Arc<str>,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<()>> {
+        self.loaded_extensions.remove(extension_id);
+
+        let languages_to_remove = self
+            .loaded_languages
+            .remove(extension_id)
+            .unwrap_or_default();
+        self.proxy.remove_languages(&languages_to_remove, &[]);
+
+        for (language_server_name, language) in self
+            .loaded_language_servers
+            .remove(extension_id)
+            .unwrap_or_default()
+        {
+            self.proxy
+                .remove_language_server(&language, &language_server_name);
+        }
+
+        let path = self.extension_dir.join(&extension_id.to_string());
+        let fs = self.fs.clone();
+        cx.spawn(|_, _| async move {
+            fs.remove_dir(
+                &path,
+                RemoveOptions {
+                    recursive: true,
+                    ignore_if_not_exists: true,
+                },
+            )
+            .await
+        })
+    }
+
+    pub fn install_extension(
+        &mut self,
+        extension: ExtensionVersion,
+        tmp_path: PathBuf,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<()>> {
+        let path = self.extension_dir.join(&extension.id);
+        let fs = self.fs.clone();
+
+        cx.spawn(|this, mut cx| async move {
+            if fs.is_dir(&path).await {
+                this.update(&mut cx, |this, cx| {
+                    this.uninstall_extension(&extension.id.clone().into(), cx)
+                })?
+                .await?;
+            }
+
+            fs.rename(&tmp_path, &path, RenameOptions::default())
+                .await?;
+
+            Self::load_extension(this, extension, &mut cx).await
+        })
+    }
+
+    pub async fn handle_sync_extensions(
+        extension_store: Model<HeadlessExtensionStore>,
+        envelope: TypedEnvelope<proto::SyncExtensions>,
+        mut cx: AsyncAppContext,
+    ) -> Result<proto::SyncExtensionsResponse> {
+        let requested_extensions =
+            envelope
+                .payload
+                .extensions
+                .into_iter()
+                .map(|p| ExtensionVersion {
+                    id: p.id,
+                    version: p.version,
+                    dev: p.dev,
+                });
+        let missing_extensions = extension_store
+            .update(&mut cx, |extension_store, cx| {
+                extension_store.sync_extensions(requested_extensions.collect(), cx)
+            })?
+            .await?;
+
+        Ok(proto::SyncExtensionsResponse {
+            missing_extensions: missing_extensions
+                .into_iter()
+                .map(|e| proto::Extension {
+                    id: e.id,
+                    version: e.version,
+                    dev: e.dev,
+                })
+                .collect(),
+            tmp_dir: paths::remote_extensions_uploads_dir()
+                .to_string_lossy()
+                .to_string(),
+        })
+    }
+
+    pub async fn handle_install_extension(
+        extensions: Model<HeadlessExtensionStore>,
+        envelope: TypedEnvelope<proto::InstallExtension>,
+        mut cx: AsyncAppContext,
+    ) -> Result<proto::Ack> {
+        let extension = envelope
+            .payload
+            .extension
+            .with_context(|| anyhow!("Invalid InstallExtension request"))?;
+
+        extensions
+            .update(&mut cx, |extensions, cx| {
+                extensions.install_extension(
+                    ExtensionVersion {
+                        id: extension.id,
+                        version: extension.version,
+                        dev: extension.dev,
+                    },
+                    PathBuf::from(envelope.payload.tmp_dir),
+                    cx,
+                )
+            })?
+            .await?;
+
+        Ok(proto::Ack {})
+    }
+}
--- a/crates/extension_host/src/wasm_host.rs
+++ b/crates/extension_host/src/wasm_host.rs
@@ -1,11 +1,11 @@
 pub mod wit;

-use crate::{ExtensionManifest, ExtensionRegistrationHooks};
+use crate::ExtensionManifest;
 use anyhow::{anyhow, bail, Context as _, Result};
 use async_trait::async_trait;
 use extension::{
-    KeyValueStoreDelegate, SlashCommand, SlashCommandArgumentCompletion, SlashCommandOutput,
-    WorktreeDelegate,
+    CodeLabel, Command, Completion, ExtensionHostProxy, KeyValueStoreDelegate, ProjectDelegate,
+    SlashCommand, SlashCommandArgumentCompletion, SlashCommandOutput, Symbol, WorktreeDelegate,
 };
 use fs::{normalize_path, Fs};
 use futures::future::LocalBoxFuture;
@@ -19,6 +19,8 @@ use futures::{
 };
 use gpui::{AppContext, AsyncAppContext, BackgroundExecutor, Task};
 use http_client::HttpClient;
+use language::LanguageName;
+use lsp::LanguageServerName;
 use node_runtime::NodeRuntime;
 use release_channel::ReleaseChannel;
 use semantic_version::SemanticVersion;
@@ -32,14 +34,13 @@ use wasmtime::{
 };
 use wasmtime_wasi::{self as wasi, WasiView};
 use wit::Extension;
-pub use wit::ExtensionProject;

 pub struct WasmHost {
    engine: Engine,
    release_channel: ReleaseChannel,
    http_client: Arc<dyn HttpClient>,
    node_runtime: NodeRuntime,
-    pub registration_hooks: Arc<dyn ExtensionRegistrationHooks>,
+    pub(crate) proxy: Arc<ExtensionHostProxy>,
    fs: Arc<dyn Fs>,
    pub work_dir: PathBuf,
    _main_thread_message_task: Task<()>,
@@ -65,6 +66,132 @@ impl extension::Extension for WasmExtension {
        self.work_dir.clone()
    }

+    async fn language_server_command(
+        &self,
+        language_server_id: LanguageServerName,
+        language_name: LanguageName,
+        worktree: Arc<dyn WorktreeDelegate>,
+    ) -> Result<Command> {
+        self.call(|extension, store| {
+            async move {
+                let resource = store.data_mut().table().push(worktree)?;
+                let command = extension
+                    .call_language_server_command(
+                        store,
+                        &language_server_id,
+                        &language_name,
+                        resource,
+                    )
+                    .await?
+                    .map_err(|err| anyhow!("{err}"))?;
+
+                Ok(command.into())
+            }
+            .boxed()
+        })
+        .await
+    }
+
+    async fn language_server_initialization_options(
+        &self,
+        language_server_id: LanguageServerName,
+        language_name: LanguageName,
+        worktree: Arc<dyn WorktreeDelegate>,
+    ) -> Result<Option<String>> {
+        self.call(|extension, store| {
+            async move {
+                let resource = store.data_mut().table().push(worktree)?;
+                let options = extension
+                    .call_language_server_initialization_options(
+                        store,
+                        &language_server_id,
+                        &language_name,
+                        resource,
+                    )
+                    .await?
+                    .map_err(|err| anyhow!("{err}"))?;
+                anyhow::Ok(options)
+            }
+            .boxed()
+        })
+        .await
+    }
+
+    async fn language_server_workspace_configuration(
+        &self,
+        language_server_id: LanguageServerName,
+        worktree: Arc<dyn WorktreeDelegate>,
+    ) -> Result<Option<String>> {
+        self.call(|extension, store| {
+            async move {
+                let resource = store.data_mut().table().push(worktree)?;
+                let options = extension
+                    .call_language_server_workspace_configuration(
+                        store,
+                        &language_server_id,
+                        resource,
+                    )
+                    .await?
+                    .map_err(|err| anyhow!("{err}"))?;
+                anyhow::Ok(options)
+            }
+            .boxed()
+        })
+        .await
+    }
+
+    async fn labels_for_completions(
+        &self,
+        language_server_id: LanguageServerName,
+        completions: Vec<Completion>,
+    ) -> Result<Vec<Option<CodeLabel>>> {
+        self.call(|extension, store| {
+            async move {
+                let labels = extension
+                    .call_labels_for_completions(
+                        store,
+                        &language_server_id,
+                        completions.into_iter().map(Into::into).collect(),
+                    )
+                    .await?
+                    .map_err(|err| anyhow!("{err}"))?;
+
+                Ok(labels
+                    .into_iter()
+                    .map(|label| label.map(Into::into))
+                    .collect())
+            }
+            .boxed()
+        })
+        .await
+    }
+
+    async fn labels_for_symbols(
+        &self,
+        language_server_id: LanguageServerName,
+        symbols: Vec<Symbol>,
+    ) -> Result<Vec<Option<CodeLabel>>> {
+        self.call(|extension, store| {
+            async move {
+                let labels = extension
+                    .call_labels_for_symbols(
+                        store,
+                        &language_server_id,
+                        symbols.into_iter().map(Into::into).collect(),
+                    )
+                    .await?
+                    .map_err(|err| anyhow!("{err}"))?;
+
+                Ok(labels
+                    .into_iter()
+                    .map(|label| label.map(Into::into))
+                    .collect())
+            }
+            .boxed()
+        })
+        .await
+    }
+
    async fn complete_slash_command_argument(
        &self,
        command: SlashCommand,
@@ -110,6 +237,25 @@ impl extension::Extension for WasmExtension {
        .await
    }

+    async fn context_server_command(
+        &self,
+        context_server_id: Arc<str>,
+        project: Arc<dyn ProjectDelegate>,
+    ) -> Result<Command> {
+        self.call(|extension, store| {
+            async move {
+                let project_resource = store.data_mut().table().push(project)?;
+                let command = extension
+                    .call_context_server_command(store, context_server_id.clone(), project_resource)
+                    .await?
+                    .map_err(|err| anyhow!("{err}"))?;
+                anyhow::Ok(command.into())
+            }
+            .boxed()
+        })
+        .await
+    }
+
    async fn suggest_docs_packages(&self, provider: Arc<str>) -> Result<Vec<String>> {
        self.call(|extension, store| {
            async move {
@@ -184,7 +330,7 @@ impl WasmHost {
        fs: Arc<dyn Fs>,
        http_client: Arc<dyn HttpClient>,
        node_runtime: NodeRuntime,
-        registration_hooks: Arc<dyn ExtensionRegistrationHooks>,
+        proxy: Arc<ExtensionHostProxy>,
        work_dir: PathBuf,
        cx: &mut AppContext,
    ) -> Arc<Self> {
@@ -200,7 +346,7 @@ impl WasmHost {
            work_dir,
            http_client,
            node_runtime,
-            registration_hooks,
+            proxy,
            release_channel: ReleaseChannel::global(cx),
            _main_thread_message_task: task,
            main_thread_message_tx: tx,
@@ -255,7 +401,7 @@ impl WasmHost {

            Ok(WasmExtension {
                manifest: manifest.clone(),
-                work_dir: this.work_dir.clone().into(),
+                work_dir: this.work_dir.join(manifest.id.as_ref()).into(),
                tx,
                zed_api_version,
            })
@@ -286,11 +432,6 @@ impl WasmHost {
            .build())
    }

-    pub fn path_from_extension(&self, id: &Arc<str>, path: &Path) -> PathBuf {
-        let extension_work_dir = self.work_dir.join(id.as_ref());
-        normalize_path(&extension_work_dir.join(path))
-    }
-
    pub fn writeable_path_from_extension(&self, id: &Arc<str>, path: &Path) -> Result<PathBuf> {
        let extension_work_dir = self.work_dir.join(id.as_ref());
        let path = normalize_path(&extension_work_dir.join(path));
--- a/crates/extension_host/src/wasm_host/wit.rs
+++ b/crates/extension_host/src/wasm_host/wit.rs
@@ -4,6 +4,7 @@ mod since_v0_0_6;
 mod since_v0_1_0;
 mod since_v0_2_0;
 use extension::{KeyValueStoreDelegate, WorktreeDelegate};
+use language::LanguageName;
 use lsp::LanguageServerName;
 use release_channel::ReleaseChannel;
 use since_v0_2_0 as latest;
@@ -57,12 +58,35 @@ pub fn wasm_api_version_range(release_channel: ReleaseChannel) -> RangeInclusive

    let max_version = match release_channel {
        ReleaseChannel::Dev | ReleaseChannel::Nightly => latest::MAX_VERSION,
-        ReleaseChannel::Stable | ReleaseChannel::Preview => since_v0_1_0::MAX_VERSION,
+        ReleaseChannel::Stable | ReleaseChannel::Preview => latest::MAX_VERSION,
    };

    since_v0_0_1::MIN_VERSION..=max_version
 }

+/// Authorizes access to use unreleased versions of the Wasm API, based on the provided [`ReleaseChannel`].
+///
+/// Note: If there isn't currently an unreleased Wasm API version this function may be unused. Don't delete it!
+pub fn authorize_access_to_unreleased_wasm_api_version(
+    release_channel: ReleaseChannel,
+) -> Result<()> {
+    let allow_unreleased_version = match release_channel {
+        ReleaseChannel::Dev | ReleaseChannel::Nightly => true,
+        ReleaseChannel::Stable | ReleaseChannel::Preview => {
+            // We always allow the latest in tests so that the extension tests pass on release branches.
+            cfg!(any(test, feature = "test-support"))
+        }
+    };
+
+    if !allow_unreleased_version {
+        Err(anyhow!(
+            "unreleased versions of the extension API can only be used on development builds of Zed"
+        ))?;
+    }
+
+    Ok(())
+}
+
 pub enum Extension {
    V020(since_v0_2_0::Extension),
    V010(since_v0_1_0::Extension),
@@ -78,20 +102,10 @@ impl Extension {
        version: SemanticVersion,
        component: &Component,
    ) -> Result<Self> {
+        // Note: The release channel can be used to stage a new version of the extension API.
+        let _ = release_channel;
+
        if version >= latest::MIN_VERSION {
-            // Note: The release channel can be used to stage a new version of the extension API.
-            // We always allow the latest in tests so that the extension tests pass on release branches.
-            let allow_latest_version = match release_channel {
-                ReleaseChannel::Dev | ReleaseChannel::Nightly => true,
-                ReleaseChannel::Stable | ReleaseChannel::Preview => {
-                    cfg!(any(test, feature = "test-support"))
-                }
-            };
-            if !allow_latest_version {
-                Err(anyhow!(
-                    "unreleased versions of the extension API can only be used on development builds of Zed"
-                ))?;
-            }
            let extension =
                latest::Extension::instantiate_async(store, component, latest::linker())
                    .await
@@ -150,7 +164,7 @@ impl Extension {
        &self,
        store: &mut Store<WasmState>,
        language_server_id: &LanguageServerName,
-        config: &LanguageServerConfig,
+        language_name: &LanguageName,
        resource: Resource<Arc<dyn WorktreeDelegate>>,
    ) -> Result<Result<Command, String>> {
        match self {
@@ -167,11 +181,26 @@ impl Extension {
                .await?
                .map(|command| command.into())),
            Extension::V004(ext) => Ok(ext
-                .call_language_server_command(store, config, resource)
+                .call_language_server_command(
+                    store,
+                    &LanguageServerConfig {
+                        name: language_server_id.0.to_string(),
+                        language_name: language_name.to_string(),
+                    },
+                    resource,
+                )
                .await?
                .map(|command| command.into())),
            Extension::V001(ext) => Ok(ext
-                .call_language_server_command(store, &config.clone().into(), resource)
+                .call_language_server_command(
+                    store,
+                    &LanguageServerConfig {
+                        name: language_server_id.0.to_string(),
+                        language_name: language_name.to_string(),
+                    }
+                    .into(),
+                    resource,
+                )
                .await?
                .map(|command| command.into())),
        }
@@ -181,7 +210,7 @@ impl Extension {
        &self,
        store: &mut Store<WasmState>,
        language_server_id: &LanguageServerName,
-        config: &LanguageServerConfig,
+        language_name: &LanguageName,
        resource: Resource<Arc<dyn WorktreeDelegate>>,
    ) -> Result<Result<Option<String>, String>> {
        match self {
@@ -210,13 +239,24 @@ impl Extension {
                .await
            }
            Extension::V004(ext) => {
-                ext.call_language_server_initialization_options(store, config, resource)
-                    .await
+                ext.call_language_server_initialization_options(
+                    store,
+                    &LanguageServerConfig {
+                        name: language_server_id.0.to_string(),
+                        language_name: language_name.to_string(),
+                    },
+                    resource,
+                )
+                .await
            }
            Extension::V001(ext) => {
                ext.call_language_server_initialization_options(
                    store,
-                    &config.clone().into(),
+                    &LanguageServerConfig {
+                        name: language_server_id.0.to_string(),
+                        language_name: language_name.to_string(),
+                    }
+                    .into(),
                    resource,
                )
                .await
--- a/crates/extension_host/src/wasm_host/wit/since_v0_0_1.rs
+++ b/crates/extension_host/src/wasm_host/wit/since_v0_0_1.rs
@@ -3,7 +3,7 @@ use crate::wasm_host::wit::since_v0_0_4;
 use crate::wasm_host::WasmState;
 use anyhow::Result;
 use async_trait::async_trait;
-use extension::WorktreeDelegate;
+use extension::{ExtensionLanguageServerProxy, WorktreeDelegate};
 use language::LanguageServerBinaryStatus;
 use semantic_version::SemanticVersion;
 use std::sync::{Arc, OnceLock};
@@ -149,8 +149,9 @@ impl ExtensionImports for WasmState {
        };

        self.host
-            .registration_hooks
-            .update_lsp_status(lsp::LanguageServerName(server_name.into()), status);
+            .proxy
+            .update_language_server_status(lsp::LanguageServerName(server_name.into()), status);
+
        Ok(())
    }

--- a/crates/extension_host/src/wasm_host/wit/since_v0_1_0.rs
+++ b/crates/extension_host/src/wasm_host/wit/since_v0_1_0.rs
@@ -5,7 +5,7 @@ use anyhow::{anyhow, bail, Context, Result};
 use async_compression::futures::bufread::GzipDecoder;
 use async_tar::Archive;
 use async_trait::async_trait;
-use extension::{KeyValueStoreDelegate, WorktreeDelegate};
+use extension::{ExtensionLanguageServerProxy, KeyValueStoreDelegate, WorktreeDelegate};
 use futures::{io::BufReader, FutureExt as _};
 use futures::{lock::Mutex, AsyncReadExt};
 use language::LanguageName;
@@ -22,7 +22,6 @@ use wasmtime::component::{Linker, Resource};
 use super::latest;

 pub const MIN_VERSION: SemanticVersion = SemanticVersion::new(0, 1, 0);
-pub const MAX_VERSION: SemanticVersion = SemanticVersion::new(0, 1, 0);

 wasmtime::component::bindgen!({
    async: true,
@@ -496,8 +495,9 @@ impl ExtensionImports for WasmState {
        };

        self.host
-            .registration_hooks
-            .update_lsp_status(::lsp::LanguageServerName(server_name.into()), status);
+            .proxy
+            .update_language_server_status(::lsp::LanguageServerName(server_name.into()), status);
+
        Ok(())
    }

--- a/Show More
+++ b/Show More